import java.util.List;
+import org.simantics.browsing.ui.common.modifiers.EnumerationValue;
import org.simantics.browsing.ui.content.Labeler.EnumerationModifier;
import org.simantics.databoard.Bindings;
import org.simantics.db.ReadGraph;
import org.simantics.db.RequestProcessor;
+import org.simantics.db.Resource;
import org.simantics.db.Session;
import org.simantics.db.VirtualGraph;
import org.simantics.db.WriteGraph;
return processor.syncRequest(new Read<String>() {
@Override
public String perform(ReadGraph graph) throws DatabaseException {
+ EnumerationValue<Resource> ev = graph.syncRequest(new GetEnumerationValue(variable.getParent(graph).getRepresents(graph)));
+ if(ev != null) {
+ return ev.getEnumeratedValue().getName();
+ }
// System.err.println(variable.getURI(graph));
return variable.getValue(graph);//variable.getPossiblePropertyValue(graph, Variables.LABEL);
}
public EnumerationValue<Resource> perform(ReadGraph graph) throws DatabaseException {
return enumerate(graph, resource);
}
+
+ public static String getEnumerationValueName(ReadGraph graph, Resource resource) throws DatabaseException {
+ Layer0 L0 = Layer0.getInstance(graph);
+ String label = graph.getPossibleRelatedValue(resource, L0.HasLabel, Bindings.STRING);
+ if(label != null)
+ return label;
+ return safeName(graph, resource);
+ }
public static EnumerationValue<Resource> enumerate(ReadGraph graph, Resource resource) throws DatabaseException {
Layer0 l0 = Layer0.getInstance(graph);
Collection<Resource> values = graph.getObjects(type, l0.ConsistsOf);
List<EnumeratedValue<Resource>> result = new ArrayList<EnumeratedValue<Resource>>(values.size());
for (Resource value : values) {
- result.add(new EnumeratedValue<Resource>(safeName(graph, value), value));
+ result.add(new EnumeratedValue<Resource>(getEnumerationValueName(graph, value), value));
}
Enumeration<Resource> enumeration = new Enumeration<Resource>(result);
return new EnumerationValue<Resource>(enumeration, enumeration.find(resource));
import org.osgi.framework.InvalidSyntaxException;
import org.osgi.framework.ServiceReference;
import org.simantics.Simantics;
+import org.simantics.browsing.ui.graph.impl.GetEnumerationValue;
import org.simantics.databoard.Bindings;
import org.simantics.databoard.binding.Binding;
import org.simantics.databoard.binding.error.BindingException;
import org.simantics.db.ReadGraph;
import org.simantics.db.Resource;
import org.simantics.db.common.NamedResource;
+import org.simantics.db.common.request.IsEnumeratedValue;
import org.simantics.db.common.request.UniqueRead;
import org.simantics.db.common.utils.NameUtils;
import org.simantics.db.exception.DatabaseException;
for(Resource assertion : graph.getAssertedObjects(data.componentType, relation)) {
try {
- expression = graph.getPossibleRelatedValue(assertion, L0.SCLValue_expression, Bindings.STRING);
+ expression = graph.getPossibleRelatedValue(assertion, L0.SCLValue_expression, Bindings.STRING);
if(expression != null) {
defaultValue = "=" + expression; //$NON-NLS-1$
- } else {
+ } else if (graph.sync(new IsEnumeratedValue(assertion))) {
+ defaultValue = GetEnumerationValue.getEnumerationValueName(graph, assertion);
+ } else {
Datatype dt = getPossibleDatatype(graph, assertion);
if (dt == null)
continue;
package org.simantics.modeling.ui.componentTypeEditor;
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.concurrent.ScheduledFuture;
import java.util.concurrent.TimeUnit;
import java.util.regex.Matcher;
import org.eclipse.ui.forms.widgets.Form;
import org.eclipse.ui.forms.widgets.FormToolkit;
import org.simantics.Simantics;
+import org.simantics.databoard.Bindings;
import org.simantics.databoard.type.NumberType;
import org.simantics.databoard.units.internal.library.UnitLibrary;
import org.simantics.databoard.util.Limit;
import org.simantics.databoard.util.Range;
import org.simantics.databoard.util.RangeException;
+import org.simantics.db.ReadGraph;
import org.simantics.db.RequestProcessor;
import org.simantics.db.Resource;
+import org.simantics.db.Statement;
import org.simantics.db.WriteGraph;
import org.simantics.db.common.NamedResource;
+import org.simantics.db.common.request.IndexRoot;
+import org.simantics.db.common.request.ResourceRead;
import org.simantics.db.common.request.WriteRequest;
import org.simantics.db.exception.DatabaseException;
import org.simantics.db.function.DbConsumer;
+import org.simantics.db.layer0.QueryIndexUtils;
import org.simantics.layer0.Layer0;
import org.simantics.modeling.userComponent.ComponentTypeCommands;
import org.simantics.scl.runtime.function.Function2;
editor.setEditor(text, selectedItem, column);
}
+ private static class TypeDefinitionMapRequest extends ResourceRead<Map<String,Resource>> {
+ public TypeDefinitionMapRequest(Resource resource) {
+ super(resource);
+ }
+
+ @Override
+ public Map<String,Resource> perform(ReadGraph graph) throws DatabaseException {
+ Layer0 L0 = Layer0.getInstance(graph);
+ Map<String,Resource> result = new HashMap<>();
+ for(Resource valueType : QueryIndexUtils.searchByType(graph, resource, L0.ValueType)) {
+ Collection<Statement> stms = graph.getAssertedStatements(valueType, L0.HasValueType);
+ if(stms.size() == 1) {
+ String sclValueType = graph.getValue(stms.iterator().next().getObject(), Bindings.STRING);
+ result.put(sclValueType, valueType);
+ }
+ }
+ return result;
+ }
+ }
+
public void editType(Table table, TableEditor editor, final ComponentTypeViewerPropertyInfo propertyInfo, TableItem selectedItem, int column, String range, final boolean convertDefaultValue) {
int extraStyle = propertyInfo.immutable ? SWT.READ_ONLY : 0;
final Combo combo = new Combo(table, SWT.NONE | extraStyle);
if (propertyInfo.immutable)
return;
+
Simantics.getSession().async(new WriteRequest() {
@Override
public void perform(WriteGraph graph)
throws DatabaseException {
graph.markUndoPoint();
- ComponentTypeCommands.editType(graph, componentType, propertyInfo.resource, convertDefaultValue, newValue);
+
+ Resource root = graph.syncRequest(new IndexRoot(componentType));
+ Map<String,Resource> typeDefinitionMap = graph.syncRequest(new TypeDefinitionMapRequest(root));
+ Resource possibleGraphType = typeDefinitionMap.get(newValue);
+
+ ComponentTypeCommands.editType(graph, componentType, propertyInfo.resource, convertDefaultValue, newValue, possibleGraphType);
if (range != null) ComponentTypeCommands.setRange(graph, componentType, propertyInfo.resource, range);
}
});
@private
transformOf element = Position (da!0) (da!1) (da!2) (da!3) (da!4) (da!5)
- where da = fromDoubleArray $ relatedValue element DIA.HasTransform
+ where da = relatedValue element DIA.HasTransform :: Vector Double
"""Creates a random GUID L0.identifier property for the specified entity resource."""
@private
hasType componentType,
hasTypedProperty
DIA.HasTransform
- (positionToDoubleArray position)
+ (positionToVector position)
G2D.Transform,
hasStatement
MOD.ElementToComponent
]
a = newOrMappedElement aName
b = newOrMappedElement bName
- ca = createConnector connection a ar
- cb = createConnector connection b br
+ ca = createConnector connection a ar DIA.HasPlainConnector
+ cb = createConnector connection b br DIA.HasArrowConnector
connectNodes ca cb
Just connection
createElement (Flag t name label output external tableBinding tableRow position joins) = do
hasType t,
hasTypedProperty
DIA.HasTransform
- (positionToDoubleArray position)
+ (positionToVector position)
G2D.Transform,
hasPossibleProperty
DIA.Flag.HasIOTableBinding
Just connection
createNode connection (Terminal elementName terminal) = do
element = newOrMappedElement elementName
- createConnector connection element terminal
+ if terminal == DIA.Flag.ConnectionPoint then
+ createConnector connection element terminal DIA.HasPlainConnector
+ else
+ createConnector connection element terminal DIA.HasPlainConnector
createNode connection (RouteLine isHorizontal position) = do
newEntity [
hasName (freshElementName ()),
hasStatement DIA.HasInteriorRouteNode.Inverse
connection
]
- createConnector connection component terminal = do
+ createConnector connection component terminal defaultHasConnector = do
connector = newResource ()
claim connector
L0.InstanceOf
DIA.Connector
claim component terminal connector
- claim connection
- DIA.HasPlainConnector
- connector
+
+ (connectionRelation, attachmentRelation) = resolveAttachmentRelation component terminal defaultHasConnector
+
+ claim connection attachmentRelation connector
+
+ execJust connectionRelation (\cr -> do
+ if existsStatement cr MOD.NeedsConnectionMappingSpecification then do
+ connectionType = singleObject cr STR.AllowsConnectionType
+ spec = singleObject connectionType MOD.ConnectionTypeToConnectionMappingSpecification
+ claim connector
+ MOD.HasConnectionMappingSpecification
+ spec
+ else ())
+
connector
connectNodes a b =
claim a DIA.AreConnected b
+ // Returns (connectionRelation :: Maybe Resource, connector attachment relation :: Resource)
+ resolveAttachmentRelation element terminal defaultAttachmentRelation =
+ if terminal == DIA.Flag.ConnectionPoint then
+ (Nothing, flagTypeToAttachmentRelation element)
+ else
+ match possibleObject terminal MOD.DiagramConnectionRelationToConnectionRelation with
+ Just connectionRelation -> (Just connectionRelation, orElse (possibleObject connectionRelation STR.HasAttachmentRelation) defaultAttachmentRelation)
+ Nothing -> (Nothing, defaultAttachmentRelation)
createElement (SVG document position) =
Just $ newEntity [
hasName (freshElementName ()),
document,
hasTypedProperty
DIA.HasTransform
- (positionToDoubleArray position)
+ (positionToVector position)
G2D.Transform
]
createRealizedFont (Font family size style) = do
label,
hasTypedProperty
DIA.HasTransform
- (positionToDoubleArray position)
+ (positionToVector position)
G2D.Transform,
hasTypedProperty
G2D.HasStrokeWidth
hasStatement DIA.HasMonitorComponent component,
hasTypedProperty
DIA.HasTransform
- (positionToDoubleArray position)
+ (positionToVector position)
G2D.Transform,
hasTypedProperty
G2D.HasStrokeWidth
text,
hasTypedProperty
DIA.HasTransform
- (positionToDoubleArray position)
+ (positionToVector position)
G2D.Transform,
hasStatement
G2D.HasHorizontalAlignment
Just c -> claimRelatedValue c L0.HasName name
Nothing -> () // This is a typical case
setConnectionName _ = ()
+ flagTypeToAttachmentRelation flag = match possibleObject flag DIA.HasFlagType with
+ Just DIA.FlagType.OutputFlag -> DIA.HasArrowConnector
+ otherwise -> DIA.HasPlainConnector
"""Returns a diagram in the given model with the given model relative path."""
diagram :: Model -> [String] -> <ReadGraph> Diagram
"""
transformElement :: (Position -> Position) -> Resource -> <WriteGraph> ()
transformElement transformer element =
- claimRelatedValue element DIA.HasTransform (positionToDoubleArray (transformer (transformOf element)))
+ claimRelatedValue element DIA.HasTransform (positionToVector (transformer (transformOf element)))
"""
transformElements transformer elements
*******************************************************************************/
package org.simantics.modeling.userComponent;
+import java.util.Collections;
import java.util.Map;
import org.simantics.databoard.Bindings;
import org.simantics.db.Statement;
import org.simantics.db.WriteGraph;
import org.simantics.db.common.CommentMetadata;
+import org.simantics.db.common.request.EnumerationMap;
+import org.simantics.db.common.request.IsEnumeratedValue;
import org.simantics.db.common.request.UnaryRead;
import org.simantics.db.common.utils.NameUtils;
import org.simantics.db.exception.DatabaseException;
import org.simantics.db.exception.ServiceException;
-import org.simantics.db.layer0.request.ModelInstances;
+import org.simantics.db.layer0.QueryIndexUtils;
import org.simantics.db.layer0.util.Layer0Utils;
import org.simantics.layer0.Layer0;
import org.simantics.modeling.ModelingResources;
import org.simantics.selectionview.SelectionViewResources;
import org.simantics.structural.stubs.StructuralResource2;
import org.simantics.structural2.utils.StructuralUtils;
+import org.simantics.utils.strings.AlphanumComparator;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public static void setRequiredType(WriteGraph g, Resource componentType, Resource property,
String requiredType) throws DatabaseException {
+ setRequiredType(g, componentType, property, requiredType, null);
+ }
+
+ public static void setRequiredType(WriteGraph g, Resource componentType, Resource property,
+ String requiredType, Resource possibleType) throws DatabaseException {
Layer0 L0 = Layer0.getInstance(g);
g.claimLiteral(property, L0.RequiresValueType, requiredType);
}
}
+ // We assert the range of the property only if we are given a dedicated graph value type
+ if(g.hasStatement(property, L0.HasRange))
+ g.deny(property, L0.HasRange);
+
+ if(possibleType != null) {
+ // We have a dedicated graph type for this SCL value type
+ if(g.hasStatement(possibleType, L0.Enumeration)) {
+ // This value type is an enumeration - let's constrain the range of this predicate to match the enumeration type only
+ g.claim(property, L0.HasRange, possibleType);
+ }
+ }
+
CommentMetadata cm = g.getMetadata(CommentMetadata.class);
g.addMetadata(cm.add("Set required type "+ requiredType + " for component/annotation " + property));
}
public static void editType(WriteGraph graph, Resource componentType, Resource property, boolean convertDefaultValue, String newValue) throws DatabaseException {
- ComponentTypeCommands.setRequiredType(graph, componentType, property, newValue);
+ editType(graph, componentType, property, convertDefaultValue, newValue, null);
+ }
+
+ public static void editType(WriteGraph graph, Resource componentType, Resource property, boolean convertDefaultValue, String newValue, Resource possibleType) throws DatabaseException {
+ ComponentTypeCommands.setRequiredType(graph, componentType, property, newValue, possibleType);
if (convertDefaultValue) {
- ComponentTypeCommands.convertDefaultValue(graph, componentType, property, newValue);
- Map<String, Resource> instances = graph.sync(new ModelInstances(componentType, componentType));
- for(Resource instance : instances.values()) {
- ComponentTypeCommands.convertInstantiatedValue(graph, instance, property, newValue);
+ ComponentTypeCommands.convertDefaultValue(graph, componentType, property, newValue, possibleType);
+ for (Resource indexRoot : Layer0Utils.listIndexRoots(graph)) {
+ for(Resource instance : QueryIndexUtils.searchByTypeShallow(graph, indexRoot, componentType)) {
+ ComponentTypeCommands.convertInstantiatedValue(graph, instance, property, newValue, componentType);
+ }
}
}
}
" in " + NameUtils.getSafeName(g, type) + ".");
return;
}
+
+ Layer0 L0 = Layer0.getInstance(g);
+ Resource range = g.getPossibleObject(relation, L0.HasRange);
+ if (range != null) {
+ if(g.hasStatement(range, L0.Enumeration)) {
+ Map<String,Resource> values = g.syncRequest(new EnumerationMap(range));
+ Resource value = values.get(valueText);
+ if (value != null) {
+ for(Resource assertion : g.getObjects(type, L0.Asserts)) {
+ Resource p = g.getSingleObject(assertion, L0.HasPredicate);
+ if (p.equals(relation)) {
+ g.deny(assertion, L0.HasObject, object);
+ g.claim(assertion, L0.HasObject, value);
+ }
+ }
+ }
+ return;
+ }
+ }
if(valueText.length() > 0 && valueText.charAt(0) == '=') {
- String expression = valueText.substring(1);
- Layer0 L0 = Layer0.getInstance(g);
+ String expression = valueText.substring(1);
ModelingResources MOD = ModelingResources.getInstance(g);
if(!g.isInstanceOf(object, MOD.SCLValue)) {
Resource assertion = g.getSingleObject(object, L0.HasObjectInverse);
} else {
- Layer0 L0 = Layer0.getInstance(g);
ModelingResources MOD = ModelingResources.getInstance(g);
if(g.isInstanceOf(object, MOD.SCLValue)) {
Resource assertion = g.getSingleObject(object, L0.HasObjectInverse);
public static void convertDefaultValue(WriteGraph g,
Resource type, Resource relation, String newSCLType) throws DatabaseException {
+ convertDefaultValue(g, type, relation, newSCLType, null);
+ }
+
+ private static Resource findAssertionWithPO(ReadGraph graph, Resource possibleType, Resource predicate, Resource object) throws DatabaseException {
+ Layer0 L0 = Layer0.getInstance(graph);
+ for(Resource assertion : graph.getObjects(possibleType, L0.Asserts)) {
+ Resource p = graph.getSingleObject(assertion, L0.HasPredicate);
+ Resource o = graph.getSingleObject(assertion, L0.HasObject);
+ if(predicate.equals(p) && object.equals(o))
+ return assertion;
+ }
+ return null;
+ }
+
+ public static void convertDefaultValue(WriteGraph g,
+ Resource type, Resource relation, String newSCLType, Resource possibleType) throws DatabaseException {
Resource object = getAssertedObject(g, type, relation);
if(object == null) {
LOGGER.warn("Didn't find assertion for " + NameUtils.getSafeName(g, relation) +
return;
}
+ Layer0 L0 = Layer0.getInstance(g);
+ if(possibleType != null) {
+ if(g.hasStatement(possibleType, L0.Enumeration)) {
+ if(!g.isInstanceOf(object, possibleType)) {
+ Map<String, Resource> enumMap = g.syncRequest(new EnumerationMap(possibleType));
+ String firstKey = Collections.min(enumMap.keySet(), AlphanumComparator.COMPARATOR);
+ Resource defaultValue = enumMap.get(firstKey);
+
+ if (defaultValue != null) {
+ Resource assertion = findAssertionWithPO(g, type, relation, object);
+ if(assertion != null) {
+ g.deny(assertion, L0.HasObject);
+ g.claim(assertion, L0.HasObject, defaultValue);
+ return;
+ } else {
+ Layer0Utils.assert_(g, type, relation, defaultValue);
+ return;
+ }
+ }
+ }
+ }
+ }
+
Tuple tuple = getDatatypeValueAndBinding(g, object, newSCLType);
if (tuple == null)
return;
- Layer0 L0 = Layer0.getInstance(g);
g.claimLiteral(object, L0.HasDataType, L0.DataType, tuple.get(0), Bindings.getBindingUnchecked(Datatype.class));
g.claimLiteral(object, L0.HasValueType, g.<String>getRelatedValue(relation, L0.RequiresValueType, Bindings.STRING), Bindings.STRING);
g.claimValue(object, tuple.get(1), (Binding)tuple.get(2));
}
- public static void convertInstantiatedValue(WriteGraph g, Resource instance, Resource relation, String newSCLType)
+ public static void convertInstantiatedValue(WriteGraph g, Resource instance, Resource relation, String newSCLType) throws DatabaseException {
+ convertInstantiatedValue(g, instance, relation, newSCLType, null);
+ }
+
+ public static void convertInstantiatedValue(WriteGraph g, Resource instance, Resource relation, String newSCLType, Resource possibleType)
throws DatabaseException {
Statement stm = g.getPossibleStatement(instance, relation);
if(stm != null && !stm.isAsserted(instance)) {
- Resource object = stm.getObject();
+ Layer0 L0 = Layer0.getInstance(g);
+ Resource object = stm.getObject();
+
+ if(g.sync(new IsEnumeratedValue(object))) {
+ if(!g.isInstanceOf(object, possibleType)) {
+ g.deny(instance, relation);
+ }
+ return;
+ }
// We can only convert literals
- Layer0 L0 = Layer0.getInstance(g);
if(!g.isInstanceOf(object, L0.Literal)) return;
Tuple tuple = getDatatypeValueAndBinding(g, object, newSCLType);
public boolean updateRange(ReadGraph g, IForwardMapping<Domain, Range> map,
Domain domainElement, Range rangeElement)
throws MappingException {
- LOGGER.info(" UpdateMethodFactory.updateRange");
+ LOGGER.trace(" UpdateMethodFactory.updateRange");
try {
return (Boolean)method.invoke(rangeElement, g, domainElement);
} catch (Exception e) {
}
private void createDomain(WriteGraph g, Link<Domain,Range> link) throws MappingException {
- LOGGER.info(" createDomain for " + link.rangeElement);
+ LOGGER.trace(" createDomain for " + link.rangeElement);
ILinkType<Domain,Range> type = schema.linkTypeOfRangeElement(link.rangeElement);
Domain domainElement = type.createDomainElement(g, link.rangeElement);
link.type = type;
@Override
public synchronized Collection<Domain> updateDomain(WriteGraph g) throws MappingException {
- LOGGER.info("Mapping.updateDomain");
+ LOGGER.trace("Mapping.updateDomain");
RangeToDomain map = new RangeToDomain(g);
ArrayList<Domain> updated = new ArrayList<Domain>();
while(!modifiedRangeLinks.isEmpty()) {
- LOGGER.info(" modifiedRangeLinks.size() = " + modifiedRangeLinks.size());
+ LOGGER.trace(" modifiedRangeLinks.size() = " + modifiedRangeLinks.size());
Link<Domain,Range> link = modifiedRangeLinks.remove(modifiedRangeLinks.size()-1);
link.rangeModified = false;
@Override
public synchronized Collection<Range> updateRange(ReadGraph g) throws MappingException {
- LOGGER.info("Mapping.updateRange");
+ LOGGER.trace("Mapping.updateRange");
DomainToRange map = new DomainToRange(g);
ArrayList<Range> updated = new ArrayList<Range>();
while(!modifiedDomainLinks.isEmpty()) {
- LOGGER.info(" modifiedDomainLinks.size() = " + modifiedDomainLinks.size());
+ LOGGER.trace(" modifiedDomainLinks.size() = " + modifiedDomainLinks.size());
Link<Domain,Range> link = modifiedDomainLinks.remove(modifiedDomainLinks.size()-1);
link.domainModified = false;
void domainModified(Link<Domain,Range> link) {
if(!link.domainModified) {
synchronized(modifiedDomainLinks) {
- LOGGER.info(" domainModified for " + link.rangeElement);
+ LOGGER.trace(" domainModified for " + link.rangeElement);
link.domainModified = true;
modifiedDomainLinks.add(link);
if(modifiedDomainLinks.size() == 1) {
public boolean updateDomain(WriteGraph g, IBackwardMapping<Domain, Range> map,
Domain domainElement, Range rangeElement)
throws MappingException {
- LOGGER.info(" MappedElementRule.updateDomain");
+ LOGGER.trace(" MappedElementRule.updateDomain");
Range value = rangeAccessor.get(rangeElement);
Domain mappedValue = value == null ? null : map.inverseMap(g, value);//map.inverseGet(value);
return domainAccessor.set(g, domainElement, mappedValue);
public boolean updateRange(ReadGraph g, IForwardMapping<Domain, Range> map,
Domain domainElement, Range rangeElement)
throws MappingException {
- LOGGER.info(" MappedElementRule.updateRange");
+ LOGGER.trace(" MappedElementRule.updateRange");
Domain value = domainAccessor.get(g, domainElement);
Range mappedValue = value == null ? null : map.map(g, value);////map.get(value);
return rangeAccessor.set(rangeElement, mappedValue);
public boolean updateDomain(WriteGraph g, IBackwardMapping<Domain, Range> map,
Domain domainElement, Range rangeElement)
throws MappingException {
- LOGGER.info(" MappedElementsRule.updateDomain");
+ LOGGER.trace(" MappedElementsRule.updateDomain");
// Snapshot the accessed range value for concurrency safety.
// NOTE: still assumes that the accessed collection is concurrent or
// synchronized for toArray to be atomic.
public boolean updateRange(ReadGraph g, IForwardMapping<Domain, Range> map,
Domain domainElement, Range rangeElement)
throws MappingException {
- LOGGER.info(" MappedElementsRule.updateRange");
+ LOGGER.trace(" MappedElementsRule.updateRange");
Collection<Domain> value = domainAccessor.get(g, domainElement);
ArrayList<Range> mappedValue = new ArrayList<Range>(value.size());
for(Domain r : value)
public boolean updateDomain(WriteGraph g, IBackwardMapping<Domain, Range> map,
Domain domainElement, Range rangeElement)
throws MappingException {
- LOGGER.info(" ValueRule.updateDomain");
+ LOGGER.trace(" ValueRule.updateDomain");
Object value = rangeAccessor.get(rangeElement);
return domainAccessor.set(g, domainElement, value);
}
public boolean updateRange(ReadGraph g, IForwardMapping<Domain, Range> map,
Domain domainElement, Range rangeElement)
throws MappingException {
- LOGGER.info(" ValueRule.updateRange");
+ LOGGER.trace(" ValueRule.updateRange");
Object value = domainAccessor.get(g, domainElement);
return rangeAccessor.set(rangeElement, value);
}
public Object get(ReadGraph g, Resource element) throws MappingException {
try {
Layer0 l0 = Layer0.getInstance(g);
- LOGGER.info(" CompoundValueAccessor.get");
+ LOGGER.trace(" CompoundValueAccessor.get");
Collection<Statement> coll = g.getStatements(element, objRelation);
Map<String,Object> map = new HashMap<String, Object>();
for (Statement c : coll) {
throws MappingException {
try {
Layer0 l0 = Layer0.getInstance(g);
- LOGGER.info(" CompoundValueAccessor.set");
+ LOGGER.trace(" CompoundValueAccessor.set");
@SuppressWarnings("unchecked")
Map<String,Object> values = (Map<String, Object>)v;
@Override
public Collection<Resource> get(ReadGraph g, Resource element) throws MappingException {
try {
- LOGGER.info(" LinkdedListAccessor.get");
+ LOGGER.trace(" LinkdedListAccessor.get");
return ListUtils.toList(g, g.getPossibleObject(element, relation));
} catch (DatabaseException e) {
throw new MappingException(e);
public boolean set(WriteGraph g, Resource element, Collection<Resource> value)
throws MappingException {
try {
- LOGGER.info(" LinkdedListAccessor.set");
+ LOGGER.trace(" LinkdedListAccessor.set");
return MappingUtils.synchronizeList(g, element, relation, listType, new ArrayList<Resource>(value), deleteExtraObjects);
} catch (DatabaseException e) {
throw new MappingException(e);
while(true) {
int cmp = currentObjects[i].compareTo(objects[j]);
if(cmp < 0) {
- LOGGER.info(" remove statement");
+ LOGGER.trace(" remove statement");
if(deleteExtraObjects)
g.deny(currentObjects[i]);
else
break;
}
else if(cmp > 0) {
- LOGGER.info(" add statement");
+ LOGGER.trace(" add statement");
g.claim(subject, predicate, objects[j]);
modified = true;
++j;
@Override
public Resource get(ReadGraph g, Resource element) throws MappingException {
try {
- LOGGER.info(" RelatedObjectAccessor.get");
+ LOGGER.trace(" RelatedObjectAccessor.get");
return g.getPossibleObject(element, relation);
} catch (DatabaseException e) {
throw new MappingException(e);
public boolean set(WriteGraph g, Resource element, Resource value)
throws MappingException {
try {
- LOGGER.info(" RelatedObjectAccessor.set");
+ LOGGER.trace(" RelatedObjectAccessor.set");
Resource resource = g.getPossibleObject(element, relation);
if(resource == null) {
if(value == null)
@Override
public Collection<Resource> get(ReadGraph g, Resource element) throws MappingException {
try {
- LOGGER.info(" RelatedObjectsAccessor.get");
+ LOGGER.trace(" RelatedObjectsAccessor.get");
return g.getObjects(element, relation);
} catch (DatabaseException e) {
throw new MappingException(e);
public boolean set(WriteGraph g, Resource element, Collection<Resource> value)
throws MappingException {
try {
- LOGGER.info(" RelatedObjectsAccessor.set");
+ LOGGER.trace(" RelatedObjectsAccessor.set");
return MappingUtils.synchronizeStatements(g, element, relation,
value.toArray(new Resource[value.size()]), deleteExtraObjects);
} catch (DatabaseException e) {
@Override
public Collection<Resource> get(ReadGraph g, Resource element) throws MappingException {
try {
- LOGGER.info(" RelatedOrderedSetElementsAccessor.get");
+ LOGGER.trace(" RelatedOrderedSetElementsAccessor.get");
return OrderedSetUtils.toList(g, element);
} catch (DatabaseException e) {
throw new MappingException(e);
public boolean set(WriteGraph g, Resource element, Collection<Resource> value)
throws MappingException {
try {
- LOGGER.info(" RelatedOrderedSetElementsAccessor.set");
+ LOGGER.trace(" RelatedOrderedSetElementsAccessor.set");
return OrderedSetUtils.set(g, element, value);
// FIXME Implement deleteExtraObjects
} catch (DatabaseException e) {
@Override
public Object get(ReadGraph g, Resource element) throws MappingException {
try {
- LOGGER.info(" RelatedValueAccessor.get");
+ LOGGER.trace(" RelatedValueAccessor.get");
Resource valueResource = g.getPossibleObject(element, relation);
if(valueResource == null)
return null;
public boolean set(WriteGraph g, Resource element, Object value)
throws MappingException {
try {
- LOGGER.info(" RelatedValueAccessor.set");
+ LOGGER.trace(" RelatedValueAccessor.set");
Statement valueStatement = g.getPossibleStatement(element, relation);
if(valueStatement == null) {
if(value == null)
@SuppressWarnings("unchecked")
T result = (T)field.get(element);
- if(LOGGER.isInfoEnabled())
- LOGGER.info(" FieldAccessor.get " +
+ if(LOGGER.isTraceEnabled())
+ LOGGER.trace(" FieldAccessor.get " +
field.getName() + " -> " + result
);
try {
Object currentValue = field.get(element);
- if(LOGGER.isInfoEnabled())
- LOGGER.info(" FieldAccessor.set " +
+ if(LOGGER.isTraceEnabled())
+ LOGGER.trace(" FieldAccessor.set " +
field.getName() + " " + currentValue +
" -> " + value
);
throws MappingException {
try {
String typeUri = (String)typeGetter.invoke(rangeElement, (Object[]) null);
- if(LOGGER.isInfoEnabled())
- LOGGER.info("SimpleLinkType.createDomainElement " +
+ if(LOGGER.isTraceEnabled())
+ LOGGER.trace("SimpleLinkType.createDomainElement " +
rangeElement.toString()
);
Resource actualDomainType = g.getResource(typeUri);
public Range createRangeElement(ReadGraph g, Resource domainElement)
throws MappingException {
try {
- if(LOGGER.isInfoEnabled())
+ if(LOGGER.isTraceEnabled())
try {
- LOGGER.info("SimpleLinkType.createRangeElement " +
+ LOGGER.trace("SimpleLinkType.createRangeElement " +
NameUtils.getSafeName(g, domainElement)
);
} catch(DatabaseException e) {
public Resource createDomainElement(org.simantics.db.WriteGraph g, Range rangeElement) throws org.simantics.objmap.exceptions.MappingException {
try {
- if(LOGGER.isInfoEnabled())
- LOGGER.info("SimpleLinkType.createDomainElement " +
+ if(LOGGER.isTraceEnabled())
+ LOGGER.trace("SimpleLinkType.createDomainElement " +
rangeElement.toString()
);
Resource result = OrderedSetUtils.create(g, domainType);
public Resource createDomainElement(WriteGraph g, Range rangeElement)
throws MappingException {
try {
- if(LOGGER.isInfoEnabled())
- LOGGER.info("SimpleLinkType.createDomainElement " +
+ if(LOGGER.isTraceEnabled())
+ LOGGER.trace("SimpleLinkType.createDomainElement " +
rangeElement.toString()
);
Resource result = g.newResource();
public Range createRangeElement(ReadGraph g, Resource domainElement)
throws MappingException {
try {
- if(LOGGER.isInfoEnabled())
+ if(LOGGER.isTraceEnabled())
try {
- LOGGER.info("SimpleLinkType.createRangeElement " +
+ LOGGER.trace("SimpleLinkType.createRangeElement " +
NameUtils.getSafeName(g, domainElement)
);
} catch(DatabaseException e) {
};
public boolean updateDomain(WriteGraph g, IBackwardMapping<Resource,Range> map, Resource domainElement, Range rangeElement) throws MappingException {
- if(LOGGER.isInfoEnabled())
+ if(LOGGER.isTraceEnabled())
try {
- LOGGER.info("SimpleLinkType.updateDomain " +
+ LOGGER.trace("SimpleLinkType.updateDomain " +
NameUtils.getSafeName(g, domainElement) + " " +
rangeElement.toString()
);
public boolean updateRange(ReadGraph g, IForwardMapping<Resource,Range> map, Resource domainElement, Range rangeElement) throws MappingException {
- if(LOGGER.isInfoEnabled())
+ if(LOGGER.isTraceEnabled())
try {
- LOGGER.info("SimpleLinkType.updateRange " +
+ LOGGER.trace("SimpleLinkType.updateRange " +
NameUtils.getSafeName(g, domainElement) + " " +
(rangeElement.getClass().getName() + "@" + Integer.toHexString(rangeElement.hashCode()))
);
public boolean updateRange(ReadGraph g, IForwardMapping<Domain, Range> map,
Domain domainElement, Range rangeElement)
throws MappingException {
- LOGGER.info(" UpdateMethodFactory.updateRange");
+ LOGGER.trace(" UpdateMethodFactory.updateRange");
try {
return (Boolean)method.invoke(rangeElement, g, domainElement);
} catch (Exception e) {
@Override
public StructuralResource get(ReadGraph g, StructuralResource element) throws MappingException {
try {
- LOGGER.info(" RelatedObjectAccessor.get");
+ LOGGER.trace(" RelatedObjectAccessor.get");
Resource res = getServiceResource(g, element);
if (res == null)
return null;
public boolean set(WriteGraph g, StructuralResource selement, StructuralResource value)
throws MappingException {
try {
- LOGGER.info(" RelatedObjectAccessor.set");
+ LOGGER.trace(" RelatedObjectAccessor.set");
Resource element = getServiceResource(g, selement);
if (element == null)
return false;
@Override
public Collection<StructuralResource> get(ReadGraph g, StructuralResource element) throws MappingException {
try {
- LOGGER.info(" RelatedObjectsAccessor.get");
+ LOGGER.trace(" RelatedObjectsAccessor.get");
Resource res = getServiceResource(g, element);
public boolean set(WriteGraph g, StructuralResource element, Collection<StructuralResource> value)
throws MappingException {
try {
- LOGGER.info(" RelatedObjectsAccessor.set");
+ LOGGER.trace(" RelatedObjectsAccessor.set");
Resource res = getServiceResource(g, element);
if (res == null)
return false;
@Override
public Collection<StructuralResource> get(ReadGraph g, StructuralResource element) throws MappingException {
try {
- LOGGER.info(" RelatedOrderedSetElementsAccessor.get");
+ LOGGER.trace(" RelatedOrderedSetElementsAccessor.get");
Resource res = getServiceResource(g, element);
if (res == null)
return Collections.emptyList();
public boolean set(WriteGraph g, StructuralResource element, Collection<StructuralResource> value)
throws MappingException {
try {
- LOGGER.info(" RelatedOrderedSetElementsAccessor.set");
+ LOGGER.trace(" RelatedOrderedSetElementsAccessor.set");
Resource res = getServiceResource(g, element);
if (res == null)
return false;
@Override
public Object get(ReadGraph g, StructuralResource element) throws MappingException {
try {
- LOGGER.info(" RelatedValueAccessor.get");
+ LOGGER.trace(" RelatedValueAccessor.get");
Resource res = getServiceResource(g, element);
if (res == null)
return null;
public boolean set(WriteGraph g, StructuralResource relement, Object value)
throws MappingException {
try {
- LOGGER.info(" RelatedValueAccessor.set");
+ LOGGER.trace(" RelatedValueAccessor.set");
Resource element = getServiceResource(g, relement);
if (element == null)
public StructuralResource get(ReadGraph g, StructuralResource element) throws MappingException {
try {
- LOGGER.info(" RelatedObjectAccessor.get");
+ LOGGER.trace(" RelatedObjectAccessor.get");
if (!element.isStructural())
return null;
public boolean set(WriteGraph g, StructuralResource element, StructuralResource value)
throws MappingException {
try {
- LOGGER.info(" RelatedObjectAccessor.set");
+ LOGGER.trace(" RelatedObjectAccessor.set");
Resource instance = StructuralUtils.getContainingInstance(element);
Resource publicRelation = null;
if (instance == null)
@Override
public Collection<StructuralResource> get(ReadGraph g, StructuralResource element) throws MappingException {
try {
- LOGGER.info(" RelatedObjectsAccessor.get");
+ LOGGER.trace(" RelatedObjectsAccessor.get");
if (!element.isStructural())
return Collections.emptyList();
public boolean set(WriteGraph g, StructuralResource element, Collection<StructuralResource> value)
throws MappingException {
try {
- LOGGER.info(" RelatedObjectsAccessor.set");
+ LOGGER.trace(" RelatedObjectsAccessor.set");
if (!element.isStructural())
return false;
public StructuralResource createDomainElement(WriteGraph g, IStructuralObject rangeElement)
throws MappingException {
try {
- if(LOGGER.isInfoEnabled())
- LOGGER.info("SimpleLinkType.createDomainElement " +
+ if(LOGGER.isTraceEnabled())
+ LOGGER.trace("SimpleLinkType.createDomainElement " +
rangeElement.toString()
);
if (rangeElement.getContext().size() == 0) {
public IStructuralObject createRangeElement(ReadGraph g, StructuralResource domainElement)
throws MappingException {
try {
- if(LOGGER.isInfoEnabled())
+ if(LOGGER.isTraceEnabled())
try {
- LOGGER.info("SimpleLinkType.createRangeElement " + NameUtils.getSafeName(g, domainElement.getResource()));
+ LOGGER.trace("SimpleLinkType.createRangeElement " + NameUtils.getSafeName(g, domainElement.getResource()));
} catch(DatabaseException e) {
throw new MappingException(e);
}
}
public boolean updateDomain(WriteGraph g, IBackwardMapping<StructuralResource,IStructuralObject> map, StructuralResource domainElement, IStructuralObject rangeElement) throws MappingException {
- if(LOGGER.isInfoEnabled())
+ if(LOGGER.isTraceEnabled())
try {
- LOGGER.info("SimpleLinkType.updateDomain " +
+ LOGGER.trace("SimpleLinkType.updateDomain " +
NameUtils.getSafeName(g, domainElement.getResource()) + " " +
rangeElement.toString()
);
public boolean updateRange(ReadGraph g, IForwardMapping<StructuralResource, IStructuralObject> map, StructuralResource domainElement, IStructuralObject rangeElement) throws MappingException {
- if(LOGGER.isInfoEnabled())
+ if(LOGGER.isTraceEnabled())
try {
- LOGGER.info("SimpleLinkType.updateRange " +
+ LOGGER.trace("SimpleLinkType.updateRange " +
NameUtils.getSafeName(g, domainElement.getResource()) + " " +
rangeElement.toString()
);
module {
export = [possibleUnsafeSclValueByName, unsafeSclValueByName, sclModuleNames, moduleByName,
- documentationOfSCLValue, sclValueRef, possibleModuleSourceText]
+ documentationOfSCLValue, sclValueRef, possibleModuleSourceText, flushModuleRepository,
+ flushDefaultModuleRepository]
}
include "./CurrentModuleRepository"
@JavaName getModule
moduleByName_ :: ModuleRepository -> String -> <Proc> Failable Module
+ @JavaName flush
+ flushModuleRepository :: ModuleRepository -> <Proc> ()
+
importJava "org.simantics.scl.compiler.source.repository.ModuleSourceRepository" where
data ModuleSourceRepository
sclValueRef name = sclValueRef_ MODULE_REPOSITORY name
+flushDefaultModuleRepository :: <Proc> ()
+flushDefaultModuleRepository = flushModuleRepository MODULE_REPOSITORY
+
possibleUnsafeSclValueByName :: String -> <Proc> Maybe a
possibleUnsafeSclValueByName name = Just (unsafeSclValueByName name) `catch` \(_ :: Exception) -> Nothing
if (moduleCache != null)
for (ModuleEntry entry : moduleCache.values())
entry.dispose();
- moduleCache = null;
+ moduleCache = new ConcurrentHashMap<String, ModuleEntry>();
}
/**
import java.io.IOException;
import java.util.ArrayList;
+import java.util.Collections;
import java.util.Map;
import java.util.function.Consumer;
import org.eclipse.swt.widgets.FontDialog;
import org.simantics.Simantics;
import org.simantics.browsing.ui.NodeContext;
+import org.simantics.browsing.ui.common.modifiers.EnumerationValue;
import org.simantics.browsing.ui.content.Labeler.DialogModifier;
+import org.simantics.browsing.ui.graph.impl.GetEnumerationValue;
import org.simantics.common.format.Formatter;
import org.simantics.databoard.Bindings;
import org.simantics.databoard.Datatypes;
import org.simantics.ui.selection.WorkbenchSelectionElement;
import org.simantics.ui.selection.WorkbenchSelectionUtils;
import org.simantics.utils.datastructures.collections.CollectionUtils;
+import org.simantics.utils.strings.AlphanumComparator;
import org.simantics.utils.ui.AdaptionUtils;
import org.simantics.utils.ui.ErrorLogger;
import org.simantics.utils.ui.ISelectionUtils;
Resource parameterResource = parameter.getRepresents(graph);
if(graph.sync(new IsEnumeratedValue(parameterResource))) {
Map<String, Resource> map = graph.sync(new InstanceEnumerationMap(parameterResource));
- return new ArrayList<String>(map.keySet());
+ ArrayList<String> values = new ArrayList<>(map.keySet());
+ Collections.sort(values, AlphanumComparator.COMPARATOR);
+ return values;
} else if(graph.isInstanceOf(parameterResource, L0.Boolean)) {
return CollectionUtils.toList("true", "false");
}
value = formatterFunction.apply(property.getValue(graph));
}
}
+
+ Resource possibleValue = context.getParent(graph).getPossibleRepresents(graph);
+ if(possibleValue != null) {
+ if(graph.syncRequest(new IsEnumeratedValue(possibleValue))) {
+ return GetEnumerationValue.getEnumerationValueName(graph, possibleValue);
+ }
+ }
+
if(value == null) {
Variant variant = property.getVariantValue(graph);
String parsedLabel = (String)_value;
Object value = parsedLabel;
+ boolean isEnumeration = false;
+ Resource possibleValue = context.getParent(graph).getPossibleRepresents(graph);
+ if(possibleValue != null) {
+ isEnumeration = graph.syncRequest(new IsEnumeratedValue(possibleValue));
+ }
+
Datatype type = context.getParent(graph).getPossibleDatatype(graph);
- if (type != null) {
+ if (type != null && !isEnumeration) {
Binding binding = Bindings.getBinding(type);
L0.HasValueType "String"
STR.Component
- L0.HasConstraint STR.ConnectionConstraint : L0.Constraint
+ L0.HasConstraint STR.ConnectionValidationConstraint : L0.Constraint
L0.Constraint.Validator
STR.Functions.connectionValidator : L0.Function
-STR.ConnectionConstraint.ErrorIssue
+STR.ConnectionValidationConstraint.ErrorIssue
@ISSUE.issue ISSUE.Severity.Error
STR.Functions.connectionIssueDescription : L0.Function
L0.HasValueType "String"
-STR.ConnectionConstraint.Source <T ISSUE.Sources.DependencyTracker
+STR.ConnectionValidationConstraint.Source <T ISSUE.Sources.DependencyTracker
L0.HasLabel "Structural connection validity"
@L0.assert ISSUE.Sources.DependencyTracker.HasType STR.Component
@L0.assert ISSUE.Sources.DependencyTracker.HasSearchType STR.Connection
public int getModuleId() {
return component.getModuleId();
}
-
+
+ public ModuleUpdaterBase<T> getUpdater() {
+ return updater;
+ }
+
public SynchronizationEventHandlerBase<T> getHandler() {
return handler;
}
+ @SuppressWarnings("unchecked")
+ public <E extends SynchronizationEventHandlerBase<?>> E getConcreteHandler() {
+ return (E) handler;
+ }
+
public void setModuleId(int moduleId) {
component.setModuleId(moduleId);
}
if(oldChildMap != null)
for(T component : oldChildMap.values()) {
component.clearParent();
- mapping.addPendingRemoval(component);
+ addPendingRemoval(component);
}
}
// Alternative implementation when uids are not available.
if(oldChildMap != null)
for(T component : oldChildMap.values()) {
component.clearParent();
- mapping.addPendingRemoval(component);
+ addPendingRemoval(component);
}
}
}
}
+ protected void addPendingRemoval(T component) {
+ if (TRACE_EVENTS)
+ System.out.println("addPendingRemoval(" + component.componentId + " : " + component.solverComponentName + ")");
+ mapping.addPendingRemoval(component);
+ }
+
private String getSubprocessName(String name,
Collection<SerializedVariable> properties) {
for(SerializedVariable property : properties)
package org.simantics.structural.synchronization.utils;
-import java.io.PrintWriter;
-
import gnu.trove.map.hash.THashMap;
import gnu.trove.procedure.TObjectObjectProcedure;
import gnu.trove.procedure.TObjectProcedure;
import gnu.trove.set.hash.THashSet;
+import java.io.PrintWriter;
+import java.util.function.Consumer;
+
/**
* The entry point to the mapping structure between Simantics database and a
* designated solver. It is used to synchronize changes from Simantics to the
return !pendingRemoval.isEmpty();
}
+ public void forEachPendingRemoval(Consumer<T> consumer) {
+ pendingRemoval.forEach(c -> {
+ consumer.accept(c);
+ return true;
+ });
+ }
+
}
for(Resource req : requiredConnections) {
if(!connections.contains(req)) {
- result.add(new StandardIssue(sr.ConnectionConstraint_ErrorIssue, component, req));
+ result.add(new StandardIssue(sr.ConnectionValidationConstraint_ErrorIssue, component, req));
}
}
Code Review / simantics / platform.git / commitdiff