gerrit.simantics Code Review - simantics/platform.git/blob

   1 package org.simantics.selectionview;
   2
   3 import java.io.IOException;
   4
   5 import org.simantics.common.format.Formatter;
   6 import org.simantics.databoard.Bindings;
   7 import org.simantics.databoard.Datatypes;
   8 import org.simantics.databoard.adapter.AdaptException;
   9 import org.simantics.databoard.binding.Binding;
  10 import org.simantics.databoard.binding.NumberBinding;
  11 import org.simantics.databoard.binding.StringBinding;
  12 import org.simantics.databoard.binding.error.BindingConstructionException;
  13 import org.simantics.databoard.binding.error.BindingException;
  14 import org.simantics.databoard.binding.mutable.MutableStringBinding;
  15 import org.simantics.databoard.parser.DataValuePrinter;
  16 import org.simantics.databoard.parser.repository.DataTypeSyntaxError;
  17 import org.simantics.databoard.parser.repository.DataValueRepository;
  18 import org.simantics.databoard.primitives.MutableString;
  19 import org.simantics.databoard.type.Datatype;
  20 import org.simantics.databoard.util.ObjectUtils;
  21 import org.simantics.db.ReadGraph;
  22 import org.simantics.db.Resource;
  23 import org.simantics.db.WriteGraph;
  24 import org.simantics.db.common.CommentMetadata;
  25 import org.simantics.db.common.adaption.SimpleContextualAdapter;
  26 import org.simantics.db.exception.DatabaseException;
  27 import org.simantics.db.layer0.util.Layer0Utils;
  28 import org.simantics.db.layer0.variable.ModelledVariablePropertyDescriptor;
  29 import org.simantics.db.layer0.variable.StandardGraphPropertyVariable;
  30 import org.simantics.db.layer0.variable.Variable;
  31 import org.simantics.db.layer0.variable.Variables;
  32 import org.simantics.layer0.Layer0;
  33 import org.simantics.modeling.ModelingResources;
  34
  35 public class DisplayValueVariableAdapter extends SimpleContextualAdapter<Variable, ModelledVariablePropertyDescriptor> {
  36
  37         final String key;
  38
  39         public DisplayValueVariableAdapter() {
  40                 key = SelectionViewResources.URIs.HasDisplayValue;
  41         }
  42
  43         public DisplayValueVariableAdapter(String key) {
  44                 this.key = key;
  45         }
  46
  47         class Impl extends StandardGraphPropertyVariable {
  48
  49                 private Datatype datatype;
  50
  51                 public Impl(ReadGraph graph, Variable parent, Resource parentResource, Datatype datatype) throws DatabaseException {
  52                         super(graph, parent, null, parentResource, graph.getResource(key));
  53                         this.datatype = datatype;
  54                 }
  55
  56                 @SuppressWarnings("unchecked")
  57                 @Override
  58                 public <T> T getValue(ReadGraph graph) throws DatabaseException {
  59                         return (T)standardGetDisplayValue1(graph, this);
  60                 }
  61
  62                 @SuppressWarnings("unchecked")
  63                 @Override
  64                 public <T> T getValue(ReadGraph graph, Binding binding) throws DatabaseException {
  65                         return (T)standardGetDisplayValue2(graph, this, binding);
  66                 }
  67
  68                 @Override
  69                 public Datatype getDatatype(ReadGraph graph) throws DatabaseException {
  70                         return datatype;
  71                 }
  72
  73                 @Override
  74                 public void setValue(WriteGraph graph, Object value) throws DatabaseException {
  75                         standardSetDisplayValue2(graph, this, value);
  76                 }
  77
  78
  79                 @Override
  80                 public void setValue(WriteGraph graph, Object _value, Binding _binding) throws DatabaseException {
  81                         standardSetDisplayValue3(graph, this, _value, _binding);
  82                 }
  83
  84         }
  85
  86         public static boolean isPrimitive(Datatype dt) {
  87                 if(Datatypes.STRING.equals(dt)) return true;
  88                 else return false;
  89         }
  90
  91         private static String possibleExpression(ReadGraph graph, Variable variable) throws DatabaseException {
  92
  93                 Layer0 L0 = Layer0.getInstance(graph);
  94                 ModelingResources MOD = ModelingResources.getInstance(graph);
  95                 Resource object = variable.getPossibleRepresents(graph);
  96                 if(object != null && graph.isInstanceOf(object, MOD.SCLValue)) {
  97                         String expression = graph.getPossibleRelatedValue(object, L0.SCLValue_expression);
  98                         if (expression != null)
  99                                 return "=" + expression;
 100                 }
 101                 return null;
 102
 103         }
 104
 105         @Override
 106         public Variable adapt(ReadGraph graph, Resource source, ModelledVariablePropertyDescriptor context) throws DatabaseException {
 107
 108 //      String value = getDisplayValue(graph, context.getVariable());
 109         return new Impl(graph, context.getVariable(), context.getSubject(), Datatypes.STRING);
 110
 111         }
 112
 113     public static Object standardGetDisplayValue1(ReadGraph graph, Variable property_) throws DatabaseException {
 114
 115         Variable property = property_.getParent(graph);
 116
 117         String expression = possibleExpression(graph, property);
 118         if(expression != null) return expression;
 119
 120         Object value = property.getValue(graph);
 121
 122         Resource formatter = property.getPossiblePropertyValue(graph, Variables.FORMATTER);
 123         if(formatter != null) {
 124                 Formatter fmt = graph.adaptContextual(formatter, property, Variable.class, Formatter.class);
 125                 value = fmt.format(value);
 126         } else {
 127
 128                 Datatype dt = property.getPossibleDatatype(graph);
 129                 if(dt != null) {
 130                         if(!isPrimitive(dt)) {
 131                                 Binding binding = Bindings.getBinding(dt);
 132                                 try {
 133                                         value = DataValuePrinter.writeValueSingleLine(binding, value);
 134                                 } catch (IOException e) {
 135                                         e.printStackTrace();
 136                                 } catch (BindingException e) {
 137                                         e.printStackTrace();
 138                                 }
 139                         }
 140                 }
 141
 142         }
 143
 144         return value != null ? value.toString() : "null";
 145
 146     }
 147
 148     public static Object standardGetDisplayValue2(ReadGraph graph, Variable property, Binding binding) throws DatabaseException {
 149
 150                 try {
 151                         return Bindings.adapt(standardGetDisplayValue1(graph, property), Bindings.STRING, binding);
 152                 } catch (AdaptException e) {
 153                         throw new DatabaseException(e);
 154                 }
 155
 156     }
 157
 158     public static void standardSetDisplayValue2(WriteGraph graph, Variable property_, Object _value) throws DatabaseException {
 159
 160                 try {
 161                         Binding binding = Bindings.getBinding(_value.getClass());
 162                         standardSetDisplayValue3(graph, property_, _value, binding);
 163                 } catch (BindingConstructionException e) {
 164                         throw new DatabaseException(e);
 165                 }
 166
 167     }
 168
 169     public static void standardSetDisplayValue3(WriteGraph graph, Variable property_, Object _value, Binding binding_) throws DatabaseException {
 170
 171         try {
 172
 173                 Variable parent = property_.getParent(graph);
 174
 175                         if(!(_value instanceof String)) throw new DatabaseException("setValue for HasDisplayValue only accepts String (got " + _value.getClass().getSimpleName() + ")");
 176
 177                         String text = (String)_value;
 178                         if(text.startsWith("=")) {
 179                             Layer0Utils.setExpression(graph, parent, text, ModelingResources.getInstance(graph).SCLValue);
 180                                 return;
 181                         }
 182
 183                 String parsedLabel = (String)_value;
 184             Object value = parsedLabel;
 185
 186             Datatype type = parent.getPossibleDatatype(graph);
 187             if (type != null) {
 188
 189                     Binding binding = Bindings.getBinding(type);
 190
 191                     if (binding instanceof StringBinding) {
 192
 193                         if (binding instanceof MutableStringBinding)
 194                             value = new MutableString(parsedLabel);
 195                         else
 196                             value = parsedLabel;
 197
 198                     } else {
 199
 200                         if (binding instanceof NumberBinding) {
 201                             parsedLabel = parsedLabel.replace(",", ".");
 202                         }
 203
 204                         value = binding.parseValue(parsedLabel, new DataValueRepository());
 205                     }
 206
 207                     //System.out.println("VariableWrite " + ObjectUtils.toString(value));
 208                     parent.setValue(graph, value, binding);
 209
 210             } else {
 211
 212                 parent.setValue(graph, value);
 213
 214             }
 215
 216
 217             // Add a comment to metadata.
 218             CommentMetadata cm = graph.getMetadata(CommentMetadata.class);
 219             graph.addMetadata(cm.add("Set value " + ObjectUtils.toString(value)));
 220
 221         } catch (DataTypeSyntaxError e) {
 222             throw new DatabaseException(e);
 223         } catch (BindingException e) {
 224             throw new DatabaseException(e);
 225         }
 226
 227     }
 228
 229     public static Datatype standardGetDisplayValueDatatype(ReadGraph graph, Variable property_) throws DatabaseException {
 230         return Datatypes.STRING;
 231     }
 232
 233 }