net.mograsim.logic.model/src/net/mograsim/logic/model/serializing/SubmodelComponentSerializer.java

   1 package net.mograsim.logic.model.serializing;
   2
   3 import java.io.IOException;
   4 import java.util.Collection;
   5 import java.util.HashMap;
   6 import java.util.Map;
   7 import java.util.function.Function;
   8
   9 import com.google.gson.JsonElement;
  10
  11 import net.haspamelodica.swt.helper.swtobjectwrappers.Point;
  12 import net.mograsim.logic.model.model.ViewModelModifiable;
  13 import net.mograsim.logic.model.model.components.GUIComponent;
  14 import net.mograsim.logic.model.model.components.submodels.SubmodelComponent;
  15 import net.mograsim.logic.model.model.wires.GUIWire;
  16 import net.mograsim.logic.model.model.wires.MovablePin;
  17 import net.mograsim.logic.model.model.wires.Pin;
  18 import net.mograsim.logic.model.serializing.SubmodelComponentParams.InterfacePinParams;
  19 import net.mograsim.logic.model.serializing.SubmodelComponentParams.SubmodelParameters;
  20 import net.mograsim.logic.model.serializing.SubmodelComponentParams.SubmodelParameters.InnerComponentParams;
  21 import net.mograsim.logic.model.serializing.SubmodelComponentParams.SubmodelParameters.InnerWireParams;
  22 import net.mograsim.logic.model.serializing.SubmodelComponentParams.SubmodelParameters.InnerWireParams.InnerPinParams;
  23 import net.mograsim.logic.model.snippets.HighLevelStateHandler;
  24 import net.mograsim.logic.model.snippets.Renderer;
  25 import net.mograsim.logic.model.snippets.SubmodelComponentSnippetSuppliers;
  26 import net.mograsim.logic.model.util.JsonHandler;
  27
  28 /**
  29  * Creates {@link SubmodelComponent}s from {@link SubmodelComponentParams}
  30  *
  31  * @author Fabian Stemmler
  32  * @author Daniel Kirschten
  33  */
  34 public final class SubmodelComponentSerializer
  35 {
  36         // convenience methods
  37
  38         /**
  39          * Like {@link #deserialize(ViewModelModifiable, SubmodelComponentParams)}, but first reading the {@link SubmodelComponentParams} from
  40          * the given file path.
  41          *
  42          * @author Daniel Kirschten
  43          */
  44         public static SubmodelComponent deserialize(ViewModelModifiable model, String sourcePath) throws IOException
  45         {
  46                 return deserialize(model, JsonHandler.readJson(sourcePath, SubmodelComponentParams.class));
  47         }
  48
  49         /**
  50          * Like {@link #deserialize(ViewModelModifiable, SubmodelComponentParams, String, JsonElement)}, but first reading the
  51          * {@link SubmodelComponentParams} from the given file path.
  52          *
  53          * @author Daniel Kirschten
  54          */
  55         public static SubmodelComponent deserialize(ViewModelModifiable model, String sourcePath, String idForSerializingOverride,
  56                         JsonElement paramsForSerializingOverride) throws IOException
  57         {
  58                 return deserialize(model, JsonHandler.readJson(sourcePath, SubmodelComponentParams.class), idForSerializingOverride,
  59                                 paramsForSerializingOverride);
  60         }
  61
  62         /**
  63          * Like {@link #deserialize(ViewModelModifiable, SubmodelComponentParams, String)}, but first reading the
  64          * {@link SubmodelComponentParams} from the given file path.
  65          *
  66          * @author Daniel Kirschten
  67          */
  68         public static SubmodelComponent deserialize(ViewModelModifiable model, String sourcePath, String name) throws IOException
  69         {
  70                 return deserialize(model, JsonHandler.readJson(sourcePath, SubmodelComponentParams.class), name);
  71         }
  72
  73         /**
  74          * Like {@link #deserialize(ViewModelModifiable, SubmodelComponentParams, String, String, JsonElement)}, but first reading the
  75          * {@link SubmodelComponentParams} from the given file path.
  76          *
  77          * @author Daniel Kirschten
  78          */
  79         public static SubmodelComponent deserialize(ViewModelModifiable model, String sourcePath, String name, String idForSerializingOverride,
  80                         JsonElement paramsForSerializingOverride) throws IOException
  81         {
  82                 return deserialize(model, JsonHandler.readJson(sourcePath, SubmodelComponentParams.class), name, idForSerializingOverride,
  83                                 paramsForSerializingOverride);
  84         }
  85
  86         /**
  87          * {@link #deserialize(ViewModelModifiable, SubmodelComponentParams, String, String, JsonElement)} with no
  88          * <code>idForSerializingOverride</code> set and using the default name.
  89          *
  90          * @author Daniel Kirschten
  91          */
  92         public static SubmodelComponent deserialize(ViewModelModifiable model, SubmodelComponentParams params)
  93         {
  94                 return deserialize(model, params, null, null, null);
  95         }
  96
  97         /**
  98          * {@link #deserialize(ViewModelModifiable, SubmodelComponentParams, String, String, JsonElement)} using the default name.
  99          *
 100          * @author Daniel Kirschten
 101          */
 102         public static SubmodelComponent deserialize(ViewModelModifiable model, SubmodelComponentParams params, String idForSerializingOverride,
 103                         JsonElement paramsForSerializingOverride)
 104         {
 105                 return deserialize(model, params, null, idForSerializingOverride, paramsForSerializingOverride);
 106         }
 107
 108         /**
 109          * {@link #deserialize(ViewModelModifiable, SubmodelComponentParams, String, String, JsonElement)} with no
 110          * <code>idForSerializingOverride</code> set.
 111          *
 112          * @author Daniel Kirschten
 113          */
 114         public static SubmodelComponent deserialize(ViewModelModifiable model, SubmodelComponentParams params, String name)
 115         {
 116                 return deserialize(model, params, name, null, null);
 117         }
 118
 119         /**
 120          * Like {@link #serialize(SubmodelComponent)}, but instead of returning the generated {@link SubmodelComponentParams} they are written
 121          * to a file at the given path.
 122          *
 123          * @author Daniel Kirschten
 124          */
 125         public static void serialize(SubmodelComponent comp, String targetPath) throws IOException
 126         {
 127                 JsonHandler.writeJson(serialize(comp), targetPath);
 128         }
 129
 130         /**
 131          * Like {@link #serialize(SubmodelComponent, Function)}, but instead of returning the generated {@link SubmodelComponentParams} they are
 132          * written to a file at the given path.
 133          *
 134          * @author Daniel Kirschten
 135          */
 136         public static void serialize(SubmodelComponent comp, IdentifierGetter idGetter, String targetPath) throws IOException
 137         {
 138                 JsonHandler.writeJson(serialize(comp, idGetter), targetPath);
 139         }
 140
 141         /**
 142          * {@link #serialize(SubmodelComponent, Function)} using a default {@link IdentifierGetter} (see <code>IdentifierGetter</code>'s
 143          * {@link IdentifierGetter#IdentifierGetter() default constructor})
 144          *
 145          * @author Daniel Kirschten
 146          */
 147         public static SubmodelComponentParams serialize(SubmodelComponent comp)
 148         {
 149                 return serialize(comp, new IdentifierGetter());
 150         }
 151
 152         // "core" methods
 153         /**
 154          * Creates a {@link SubmodelComponent} from the specified {@link SubmodelComponentParams} with the given name.
 155          * <p>
 156          * When serializing a <code>SubmodelComponent</code>, it is undesired for every subcomponent to be serialized with its complete inner
 157          * structure. Instead, these sub-<code>SubmodelComponent</code>s should be serialized with the ID and params which were used to
 158          * determine the <code>SubmodelComponentParams</code> defining the sub-<code>SubmodelComponent</code>. Because of this, it is possible
 159          * to override the ID and params used in {@link #serialize(SubmodelComponent, Function) serialize(...)} to describe this subcomponent.
 160          * See there for details.
 161          *
 162          * @author Fabian Stemmler
 163          * @author Daniel Kirschten
 164          */
 165         @SuppressWarnings("unused") // for GUIWire being created
 166         public static SubmodelComponent deserialize(ViewModelModifiable model, SubmodelComponentParams params, String name,
 167                         String idForSerializingOverride, JsonElement paramsForSerializingOverride)
 168         {
 169                 DeserializedSubmodelComponent comp = new DeserializedSubmodelComponent(model, name, idForSerializingOverride,
 170                                 paramsForSerializingOverride);
 171                 comp.setSubmodelScale(params.submodel.innerScale);
 172                 comp.setSize(params.width, params.height);
 173                 for (InterfacePinParams iPinParams : params.interfacePins)
 174                         comp.addSubmodelInterface(
 175                                         new MovablePin(comp, iPinParams.name, iPinParams.logicWidth, iPinParams.location.x, iPinParams.location.y));
 176                 SubmodelParameters submodelParams = params.submodel;
 177                 ViewModelModifiable submodelModifiable = comp.getSubmodelModifiable();
 178                 Map<String, GUIComponent> componentsByName = submodelModifiable.getComponentsByName();
 179                 GUIComponent[] components = new GUIComponent[submodelParams.subComps.length];
 180                 for (int i = 0; i < components.length; i++)
 181                 {
 182                         InnerComponentParams cParams = submodelParams.subComps[i];
 183                         components[i] = IndirectGUIComponentCreator.createComponent(submodelModifiable, cParams.id, cParams.params, cParams.name);
 184                         components[i].moveTo(cParams.pos.x, cParams.pos.y);
 185                 }
 186
 187                 for (int i = 0; i < submodelParams.innerWires.length; i++)
 188                 {
 189                         InnerWireParams innerWire = submodelParams.innerWires[i];
 190                         new GUIWire(submodelModifiable, innerWire.name, componentsByName.get(innerWire.pin1.compName).getPin(innerWire.pin1.pinName),
 191                                         componentsByName.get(innerWire.pin2.compName).getPin(innerWire.pin2.pinName), innerWire.path);
 192                 }
 193                 comp.setSymbolRenderer(SubmodelComponentSnippetSuppliers.symbolRendererSupplier.getSnippetSupplier(params.symbolRendererSnippetID)
 194                                 .create(comp, params.symbolRendererParams));
 195                 comp.setOutlineRenderer(SubmodelComponentSnippetSuppliers.outlineRendererSupplier
 196                                 .getSnippetSupplier(params.outlineRendererSnippetID).create(comp, params.outlineRendererParams));
 197                 comp.setHighLevelStateHandler(SubmodelComponentSnippetSuppliers.highLevelStateHandlerSupplier
 198                                 .getSnippetSupplier(params.highLevelStateHandlerSnippetID).create(comp, params.highLevelStateHandlerParams));
 199                 return comp;
 200         }
 201
 202         /**
 203          * Returns {@link SubmodelComponentParams}, which describe this {@link SubmodelComponent}. <br>
 204          * Subcomponents are serialized in the following way: <br>
 205          * If a subcomponent is a <code>SubmodelComponent</code> which has been deserialized, and it has an
 206          * {@link DeserializedSubmodelComponent#idForSerializingOverride idForSerializingOverride} set (e.g. non-null; see
 207          * {@link #deserialize(ViewModelModifiable, SubmodelComponentParams, String, String, JsonElement) deserialize(...)}), this ID and the
 208          * component's {@link DeserializedSubmodelComponent#paramsForSerializingOverride paramsForSerializingOverride} are written.<br>
 209          * If this case doesn't apply (e.g. if the subcomponent is not a <code>SubmodelComponent</code>; or it is a
 210          * <code>SubmodelComponent</code>, but hasn't been deserialized; or it has no
 211          * {@link DeserializedSubmodelComponent#idForSerializingOverride idForSerializingOverride} set), the ID defined by <code>idGetter</code>
 212          * and the params obtained by {@link GUIComponent#getParamsForSerializing() getParams()} are written.<br>
 213          * CodeSnippets are serialized using the ID defined by <code>idGetter</code> and the params obtained by the respective
 214          * <coce>getParamsForSerializing</code> methods ({@link Renderer#getParamsForSerializing()}).
 215          *
 216          * @author Fabian Stemmler
 217          * @author Daniel Kirschten
 218          */
 219         public static SubmodelComponentParams serialize(SubmodelComponent comp, IdentifierGetter idGetter)
 220         {
 221                 SubmodelParameters submodelParams = new SubmodelParameters();
 222                 submodelParams.innerScale = comp.getSubmodelScale();
 223
 224                 Map<String, GUIComponent> components = new HashMap<>(comp.submodel.getComponentsByName());
 225                 components.remove(SubmodelComponent.SUBMODEL_INTERFACE_NAME);
 226                 InnerComponentParams[] componentParams = new InnerComponentParams[components.size()];
 227                 int i1 = 0;
 228                 for (GUIComponent innerComponent : components.values())
 229                 {
 230                         InnerComponentParams innerComponentParams = new InnerComponentParams();
 231                         componentParams[i1] = innerComponentParams;
 232                         innerComponentParams.pos = new Point(innerComponent.getPosX(), innerComponent.getPosY());
 233                         DeserializedSubmodelComponent innerCompCasted;
 234                         if (innerComponent instanceof DeserializedSubmodelComponent
 235                                         && (innerCompCasted = (DeserializedSubmodelComponent) innerComponent).idForSerializingOverride != null)
 236                         {
 237                                 innerComponentParams.id = innerCompCasted.idForSerializingOverride;
 238                                 innerComponentParams.params = innerCompCasted.paramsForSerializingOverride;
 239                         } else
 240                         {
 241                                 innerComponentParams.id = idGetter.componentIDs.apply(innerComponent);
 242                                 innerComponentParams.params = innerComponent.getParamsForSerializing(idGetter);
 243                         }
 244                         innerComponentParams.name = innerComponent.name;
 245                         i1++;
 246                 }
 247                 submodelParams.subComps = componentParams;
 248
 249                 Collection<GUIWire> wires = comp.submodel.getWiresByName().values();
 250                 InnerWireParams wireParams[] = new InnerWireParams[wires.size()];
 251                 i1 = 0;
 252                 for (GUIWire innerWire : wires)
 253                 {
 254                         InnerWireParams innerWireParams = new InnerWireParams();
 255                         wireParams[i1] = innerWireParams;
 256                         InnerPinParams pin1Params = new InnerPinParams(), pin2Params = new InnerPinParams();
 257
 258                         pin1Params.pinName = innerWire.getPin1().name;
 259                         pin1Params.compName = innerWire.getPin1().component.name;
 260                         pin2Params.pinName = innerWire.getPin2().name;
 261                         pin2Params.compName = innerWire.getPin2().component.name;
 262                         innerWireParams.name = innerWire.name;
 263                         innerWireParams.pin1 = pin1Params;
 264                         innerWireParams.pin2 = pin2Params;
 265                         innerWireParams.path = innerWire.getPath();
 266                         i1++;
 267                 }
 268                 submodelParams.innerWires = wireParams;
 269
 270                 SubmodelComponentParams params = new SubmodelComponentParams();
 271                 params.submodel = submodelParams;
 272
 273                 params.width = comp.getWidth();
 274                 params.height = comp.getHeight();
 275
 276                 InterfacePinParams[] iPins = new InterfacePinParams[comp.getPins().size()];
 277                 int i = 0;
 278                 for (Pin p : comp.getPins().values())
 279                 {
 280                         InterfacePinParams iPinParams = new InterfacePinParams();
 281                         iPins[i] = iPinParams;
 282                         iPinParams.location = p.getRelPos();
 283                         iPinParams.name = p.name;
 284                         iPinParams.logicWidth = p.logicWidth;
 285                         i++;
 286                 }
 287                 params.interfacePins = iPins;
 288
 289                 Renderer symbolRenderer = comp.getSymbolRenderer();
 290                 if (symbolRenderer != null)
 291                 {
 292                         params.symbolRendererSnippetID = idGetter.symbolRendererIDs.apply(symbolRenderer);
 293                         params.symbolRendererParams = symbolRenderer.getParamsForSerializingJSON(idGetter);
 294                 }
 295
 296                 Renderer outlineRenderer = comp.getOutlineRenderer();
 297                 if (outlineRenderer != null)
 298                 {
 299                         params.outlineRendererSnippetID = idGetter.outlineRendererIDs.apply(outlineRenderer);
 300                         params.outlineRendererParams = outlineRenderer.getParamsForSerializingJSON(idGetter);
 301                 }
 302
 303                 HighLevelStateHandler highLevelStateHandler = comp.getHighLevelStateHandler();
 304                 if (highLevelStateHandler != null)
 305                 {
 306                         params.highLevelStateHandlerSnippetID = idGetter.highLevelStateHandlerIDs.apply(highLevelStateHandler);
 307                         params.highLevelStateHandlerParams = highLevelStateHandler.getParamsForSerializingJSON(idGetter);
 308                 }
 309
 310                 return params;
 311         }
 312 }