net.mograsim.logic.ui/src/net/mograsim/logic/ui/modeladapter/ViewLogicModelAdapter.java

   1 package net.mograsim.logic.ui.modeladapter;
   2
   3 import java.util.Collections;
   4 import java.util.HashMap;
   5 import java.util.HashSet;
   6 import java.util.List;
   7 import java.util.Map;
   8 import java.util.Map.Entry;
   9 import java.util.Set;
  10 import java.util.function.Function;
  11 import java.util.stream.Collectors;
  12
  13 import net.mograsim.logic.core.timeline.Timeline;
  14 import net.mograsim.logic.core.wires.Wire;
  15 import net.mograsim.logic.core.wires.Wire.ReadEnd;
  16 import net.mograsim.logic.ui.model.ViewModel;
  17 import net.mograsim.logic.ui.model.components.GUIComponent;
  18 import net.mograsim.logic.ui.model.components.submodels.SubmodelComponent;
  19 import net.mograsim.logic.ui.model.components.submodels.SubmodelInterface;
  20 import net.mograsim.logic.ui.model.wires.GUIWire;
  21 import net.mograsim.logic.ui.model.wires.Pin;
  22 import net.mograsim.logic.ui.model.wires.WireCrossPoint;
  23 import net.mograsim.logic.ui.modeladapter.componentadapters.ComponentAdapter;
  24
  25 public class ViewLogicModelAdapter
  26 {
  27         private final static Map<Class<? extends GUIComponent>, ComponentAdapter<? extends GUIComponent>> componentAdapters = new HashMap<>();
  28
  29         public static void addComponentAdapter(ComponentAdapter<? extends GUIComponent> componentAdapter)
  30         {
  31                 componentAdapters.put(componentAdapter.getSupportedClass(), componentAdapter);
  32         }
  33
  34         public static Timeline convert(ViewModel viewModel, LogicModelParameters params)
  35         {
  36                 // TODO replace Timeline with LogicModel as soon as it exists
  37                 Timeline timeline = new Timeline(10);
  38
  39                 convert(viewModel, params, timeline, Map.of());
  40
  41                 return timeline;
  42         }
  43
  44         private static void convert(ViewModel viewModel, LogicModelParameters params, Timeline timeline, Map<Pin, Wire> externalWires)
  45         {
  46                 Map<Pin, Wire> logicWiresPerPin = convertWires(getAllPins(viewModel), viewModel.getWires(), externalWires, params, timeline);
  47                 Map<Pin, Wire> logicWiresPerPinUnmodifiable = Collections.unmodifiableMap(logicWiresPerPin);
  48
  49                 for (GUIComponent guiComp : viewModel.getComponents())
  50                 {
  51                         if (guiComp instanceof SubmodelComponent)
  52                         {
  53                                 SubmodelComponent guiCompCasted = (SubmodelComponent) guiComp;
  54                                 Map<String, Pin> supermodelPins = guiCompCasted.getSupermodelPins();
  55                                 Map<Pin, Wire> externalWiresForSubmodel = supermodelPins.entrySet().stream()
  56                                                 .collect(Collectors.toMap(e -> guiCompCasted.getSubmodelPin(e.getKey()), e -> logicWiresPerPin.get(e.getValue())));
  57                                 convert(guiCompCasted.submodel, params, timeline, externalWiresForSubmodel);
  58                         } else if (guiComp instanceof WireCrossPoint)
  59                         {
  60                                 WireCrossPoint guiCompCasted = (WireCrossPoint) guiComp;
  61                                 guiCompCasted.setLogicModelBinding(logicWiresPerPin.get(guiCompCasted.getPin()).createReadOnlyEnd());
  62                         } else if (!(guiComp instanceof SubmodelInterface))// nothing to do for SubmodelInterfaces
  63                                 createAndLinkComponent(timeline, params, guiComp, logicWiresPerPinUnmodifiable, componentAdapters.get(guiComp.getClass()));
  64                 }
  65         }
  66
  67         private static Set<Pin> getAllPins(ViewModel viewModel)
  68         {
  69                 return viewModel.getComponents().stream().flatMap(component -> component.getPins().values().stream()).collect(Collectors.toSet());
  70         }
  71
  72         private static Map<Pin, Wire> convertWires(Set<Pin> allPins, List<GUIWire> wires, Map<Pin, Wire> externalWires,
  73                         LogicModelParameters params, Timeline timeline)
  74         {
  75                 Map<Pin, Set<Pin>> connectedPinGroups = getConnectedPinGroups(allPins, wires);
  76                 Map<Pin, Wire> logicWiresPerPin = createLogicWires(params, timeline, connectedPinGroups, externalWires);
  77                 setGUIWiresLogicModelBinding(wires, logicWiresPerPin);
  78                 return logicWiresPerPin;
  79         }
  80
  81         private static Map<Pin, Wire> createLogicWires(LogicModelParameters params, Timeline timeline, Map<Pin, Set<Pin>> connectedPinGroups,
  82                         Map<Pin, Wire> externalWires)
  83         {
  84                 Map<Pin, Wire> logicWiresPerPin = new HashMap<>();
  85                 Map<Set<Pin>, Wire> logicWiresPerPinGroup = new HashMap<>();
  86                 for (Entry<Pin, Set<Pin>> e : connectedPinGroups.entrySet())
  87                         logicWiresPerPin.put(e.getKey(), logicWiresPerPinGroup.computeIfAbsent(e.getValue(), set ->
  88                         {
  89                                 Wire externalWire = null;
  90                                 for (Pin p : set)
  91                                 {
  92                                         Wire externalWireCandidate = externalWires.get(p);
  93                                         if (externalWireCandidate != null)
  94                                                 if (externalWire == null)
  95                                                         externalWire = externalWireCandidate;
  96                                                 else if (externalWire.length == externalWireCandidate.length)
  97                                                         Wire.fuse(externalWire, externalWireCandidate);
  98                                                 else
  99                                                         throw new IllegalArgumentException(
 100                                                                         "Two pins to external wires with different logicWidths can't be connected directly");
 101                                 }
 102                                 return externalWire == null ? new Wire(timeline, e.getKey().logicWidth, params.wireTravelTime) : externalWire;
 103                         }));
 104                 return logicWiresPerPin;
 105         }
 106
 107         private static void setGUIWiresLogicModelBinding(List<GUIWire> wires, Map<Pin, Wire> logicWiresPerPin)
 108         {
 109                 Map<Wire, ReadEnd> guiWireSharedReadEnd = logicWiresPerPin.values().stream().distinct()
 110                                 .collect(Collectors.toMap(Function.identity(), Wire::createReadOnlyEnd));
 111                 for (GUIWire guiWire : wires)
 112                         guiWire.setLogicModelBinding(guiWireSharedReadEnd.get(logicWiresPerPin.get(guiWire.getPin1())));
 113         }
 114
 115         private static Map<Pin, Set<Pin>> getConnectedPinGroups(Set<Pin> allPins, List<GUIWire> wires)
 116         {
 117                 Map<Pin, Set<Pin>> connectedPinsPerPin = new HashMap<>();
 118
 119                 for (Pin p : allPins)
 120                 {
 121                         HashSet<Pin> connectedPins = new HashSet<>();
 122                         connectedPins.add(p);
 123                         connectedPinsPerPin.put(p, connectedPins);
 124                 }
 125
 126                 wires.forEach(wire ->
 127                 {
 128                         Pin pin1 = wire.getPin1();
 129                         Pin pin2 = wire.getPin2();
 130
 131                         Set<Pin> pin1ConnectedPins = connectedPinsPerPin.get(pin1);
 132                         Set<Pin> pin2ConnectedPins = connectedPinsPerPin.get(pin2);
 133
 134                         pin1ConnectedPins.addAll(pin2ConnectedPins);
 135                         pin1ConnectedPins.add(pin1);
 136                         pin1ConnectedPins.add(pin2);
 137
 138                         pin2ConnectedPins.forEach(pin -> connectedPinsPerPin.put(pin, pin1ConnectedPins));
 139                 });
 140                 return connectedPinsPerPin;
 141         }
 142
 143         @SuppressWarnings("unchecked")
 144         private static <G extends GUIComponent> void createAndLinkComponent(Timeline timeline, LogicModelParameters params,
 145                         GUIComponent guiComponent, Map<Pin, Wire> logicWiresPerPin, ComponentAdapter<G> adapter)
 146         {
 147                 if (adapter == null)
 148                         throw new IllegalArgumentException("Unknown component class: " + guiComponent.getClass());
 149                 adapter.createAndLinkComponent(timeline, params, (G) guiComponent, logicWiresPerPin);
 150         }
 151
 152         private ViewLogicModelAdapter()
 153         {
 154                 throw new UnsupportedOperationException("No ViewLogicModelConverter instances");
 155         }
 156 }