bundles/org.simantics.db.layer0/src/org/simantics/db/layer0/genericrelation/DependencyChanges.java

   1 package org.simantics.db.layer0.genericrelation;
   2
   3 import java.io.IOException;
   4 import java.util.ArrayList;
   5 import java.util.Map;
   6 import java.util.TreeMap;
   7
   8 import org.simantics.databoard.Databoard;
   9 import org.simantics.databoard.annotations.Arguments;
  10 import org.simantics.databoard.annotations.Union;
  11 import org.simantics.databoard.binding.Binding;
  12 import org.simantics.databoard.binding.error.BindingConstructionException;
  13 import org.simantics.databoard.serialization.SerializationException;
  14 import org.simantics.databoard.serialization.Serializer;
  15 import org.simantics.databoard.serialization.SerializerConstructionException;
  16 import org.simantics.db.Metadata;
  17 import org.simantics.db.ReadGraph;
  18 import org.simantics.db.Resource;
  19 import org.simantics.db.Session;
  20 import org.simantics.db.common.utils.NameUtils;
  21 import org.simantics.db.exception.DatabaseException;
  22 import org.simantics.layer0.Layer0;
  23
  24 public class DependencyChanges implements Metadata {
  25
  26     public final @Arguments({Resource.class, Change[].class}) TreeMap<Resource, Change[]> modelChanges;
  27     public final boolean hasUnresolved;
  28
  29     public DependencyChanges(TreeMap<Resource, Change[]> modelChanges, boolean hasUnresolved) {
  30         this.modelChanges = modelChanges;
  31         this.hasUnresolved = hasUnresolved;
  32     }
  33
  34     public DependencyChanges(Map<Resource, ArrayList<Change>> _modelChanges, boolean hasUnresolved) {
  35         this(new TreeMap<Resource, Change[]>(), hasUnresolved);
  36         for(Map.Entry<Resource, ArrayList<Change>> entry : _modelChanges.entrySet()) {
  37             ArrayList<Change> value = entry.getValue();
  38             modelChanges.put(entry.getKey(), value.toArray(new Change[value.size()]));
  39         }
  40     }
  41
  42     public static enum ChangeType {
  43         LINK_CHANGE, COMPONENT_ADDITION, COMPONENT_REMOVAL,
  44         COMPONENT_MODIFICATION
  45     }
  46
  47     @Union({LinkChange.class,
  48         ComponentAddition.class,
  49         ComponentRemoval.class,
  50         ComponentModification.class})
  51     public static interface Change {
  52         ChangeType getType();
  53         String toString(ReadGraph graph) throws DatabaseException;
  54     }
  55
  56     public static class LinkChange implements Change {
  57         public final Resource component;
  58         public LinkChange(Resource component) {
  59             this.component = component;
  60         }
  61         @Override
  62         public ChangeType getType() {
  63             return ChangeType.LINK_CHANGE;
  64         }
  65         @Override
  66         public String toString(ReadGraph graph) throws DatabaseException {
  67                 return "LinkChange[" + NameUtils.getSafeName(graph, component, true) + "]";
  68         }
  69     }
  70
  71     public static class ComponentAddition implements Change {
  72         public final Resource component;
  73         public final Resource parent;
  74         public ComponentAddition(Resource component, Resource parent) {
  75             this.component = component;
  76             this.parent = parent;
  77         }
  78         @Override
  79         public ChangeType getType() {
  80             return ChangeType.COMPONENT_ADDITION;
  81         }
  82         @Override
  83         public String toString() {
  84                 return "ComponentAddition[" + component + "]";
  85         }
  86         public boolean isValid(ReadGraph graph) throws DatabaseException {
  87                 return graph.hasStatement(component, Layer0.getInstance(graph).PartOf, parent);
  88         }
  89         @Override
  90         public String toString(ReadGraph graph) throws DatabaseException {
  91                 return "ComponentAddition[" + NameUtils.getSafeName(graph, component, true) + "]";
  92         }
  93     }
  94
  95     public static class ComponentRemoval implements Change {
  96         public final Resource component;
  97         public final Resource parent;
  98         public ComponentRemoval(Resource component, Resource parent) {
  99             this.component = component;
 100             this.parent = parent;
 101         }
 102         @Override
 103         public ChangeType getType() {
 104             return ChangeType.COMPONENT_REMOVAL;
 105         }
 106         public boolean isValid(ReadGraph graph) throws DatabaseException {
 107                 return !graph.hasStatement(component, Layer0.getInstance(graph).PartOf, parent);
 108         }
 109         @Override
 110         public String toString(ReadGraph graph) throws DatabaseException {
 111                 return "ComponentRemoval[component=" + NameUtils.getSafeName(graph, component, true) + ", parent=" + NameUtils.getSafeName(graph, parent, true) + "]";
 112         }
 113     }
 114
 115     public static class ComponentModification implements Change {
 116         public final Resource component;
 117         public ComponentModification(Resource component) {
 118             this.component = component;
 119         }
 120         @Override
 121         public ChangeType getType() {
 122             return ChangeType.COMPONENT_MODIFICATION;
 123         }
 124         @Override
 125         public String toString(ReadGraph graph) throws DatabaseException {
 126                 return "ComponentModification[" + NameUtils.getSafeName(graph, component, true) + "]";
 127         }
 128     }
 129
 130     public Change[] get(Resource model) {
 131         return modelChanges.get(model);
 132     }
 133
 134     public Map<Resource, Change[]> get() {
 135         return modelChanges;
 136     }
 137
 138     @Override
 139     public byte[] serialise(Session session) {
 140         try {
 141                 Databoard databoard = session.getService( Databoard.class );
 142                 Binding binding = databoard.getBinding( DependencyChanges.class );
 143                 Serializer serializer = databoard.getSerializer( binding );
 144             return serializer.serialize(this);
 145         } catch (SerializationException e) {
 146             e.printStackTrace();
 147         } catch (IOException e) {
 148                         // TODO Auto-generated catch block
 149                         e.printStackTrace();
 150                 } catch (SerializerConstructionException e) {
 151                         // TODO Auto-generated catch block
 152                         e.printStackTrace();
 153                 } catch (BindingConstructionException e) {
 154                         // TODO Auto-generated catch block
 155                         e.printStackTrace();
 156                 }
 157         return new byte[0];
 158     }
 159
 160     public static DependencyChanges deserialise(Session session, byte[] input) {
 161         try {
 162                 Databoard databoard = session.getService( Databoard.class );
 163                 Binding binding = databoard.getBinding( DependencyChanges.class );
 164                 Serializer serializer = databoard.getSerializer( binding );
 165             return (DependencyChanges) serializer.deserialize(input);
 166         } catch (SerializationException e) {
 167             e.printStackTrace();
 168         } catch (IOException e) {
 169             e.printStackTrace();
 170         } catch (SerializerConstructionException e) {
 171                         e.printStackTrace();
 172                 } catch (BindingConstructionException e) {
 173                         e.printStackTrace();
 174                 }
 175         return null;
 176     }
 177
 178     public boolean isEmpty() {
 179         return modelChanges.isEmpty() && !hasUnresolved;
 180     }
 181
 182 }