net.mograsim.logic.model/src/net/mograsim/logic/model/snippets/highlevelstatehandlers/standard/StandardHighLevelStateHandler.java

   1 package net.mograsim.logic.model.snippets.highlevelstatehandlers.standard;
   2
   3 import java.util.HashMap;
   4 import java.util.Map;
   5 import java.util.function.BiFunction;
   6 import java.util.function.Function;
   7
   8 import net.mograsim.logic.model.model.components.submodels.SubmodelComponent;
   9 import net.mograsim.logic.model.snippets.HighLevelStateHandler;
  10 import net.mograsim.logic.model.snippets.SnippetDefinintion;
  11 import net.mograsim.logic.model.snippets.SubmodelComponentSnippetSuppliers;
  12 import net.mograsim.logic.model.snippets.highlevelstatehandlers.standard.atomic.AtomicHighLevelStateHandler;
  13 import net.mograsim.logic.model.snippets.highlevelstatehandlers.standard.atomic.AtomicHighLevelStateHandler.AtomicHighLevelStateHandlerParams;
  14 import net.mograsim.logic.model.snippets.highlevelstatehandlers.standard.subcomponent.SubcomponentHighLevelStateHandler;
  15 import net.mograsim.logic.model.snippets.highlevelstatehandlers.standard.subcomponent.SubcomponentHighLevelStateHandler.SubcomponentHighLevelStateHandlerParams;
  16
  17 public class StandardHighLevelStateHandler implements HighLevelStateHandler
  18 {
  19         private final SubmodelComponent component;
  20         private final Map<String, SubcomponentHighLevelStateHandler> subcomponentHighLevelStateHandlers;
  21         private final Map<String, AtomicHighLevelStateHandler> atomicHighLevelStateHandlers;
  22
  23         public StandardHighLevelStateHandler(SubmodelComponent component)
  24         {
  25                 this(component, null);
  26         }
  27
  28         public StandardHighLevelStateHandler(SubmodelComponent component, StandardHighLevelStateHandlerParams params)
  29         {
  30                 this.component = component;
  31                 this.subcomponentHighLevelStateHandlers = new HashMap<>();
  32                 this.atomicHighLevelStateHandlers = new HashMap<>();
  33                 if (params != null)
  34                 {
  35                         params.subcomponentHighLevelStates.forEach(this::addSubcomponentHighLevelState);
  36                         params.atomicHighLevelStates.forEach(this::addAtomicHighLevelState);
  37                 }
  38         }
  39
  40         public SubcomponentHighLevelStateHandler addSubcomponentHighLevelState(String subcomponentStateID,
  41                         SubcomponentHighLevelStateHandlerParams handlerParams)
  42         {
  43                 return addSubcomponentHighLevelState(subcomponentStateID,
  44                                 StandardHighLevelStateHandlerSnippetSuppliers.subcomponentHandlerSupplier.getSnippetSupplier(handlerParams.id)::create,
  45                                 handlerParams.params);
  46         }
  47
  48         public <P, H extends SubcomponentHighLevelStateHandler> H addSubcomponentHighLevelState(String subcomponentStateID,
  49                         BiFunction<HighLevelStateHandlerContext, P, H> handlerConstructor, P handlerParams)
  50         {
  51                 return addSubcomponentHighLevelState(subcomponentStateID, c -> handlerConstructor.apply(c, handlerParams));
  52         }
  53
  54         public <H extends SubcomponentHighLevelStateHandler> H addSubcomponentHighLevelState(String subcomponentStateID,
  55                         Function<HighLevelStateHandlerContext, H> handlerConstructor)
  56         {
  57                 HighLevelStateHandlerContext context = new HighLevelStateHandlerContext(component, subcomponentStateID);
  58                 H handler = handlerConstructor.apply(context);
  59                 addSubcomponentHighLevelState(subcomponentStateID, handler);
  60                 return handler;
  61         }
  62
  63         public void addSubcomponentHighLevelState(String subcomponentStateID, SubcomponentHighLevelStateHandler handler)
  64         {
  65                 checkHighLevelStateIDPart(subcomponentStateID);
  66                 subcomponentHighLevelStateHandlers.put(subcomponentStateID, handler);
  67         }
  68
  69         public AtomicHighLevelStateHandler addAtomicHighLevelState(String atomicStateID, AtomicHighLevelStateHandlerParams handlerParams)
  70         {
  71                 return addAtomicHighLevelState(atomicStateID,
  72                                 StandardHighLevelStateHandlerSnippetSuppliers.atomicHandlerSupplier.getSnippetSupplier(handlerParams.id)::create,
  73                                 handlerParams.params);
  74         }
  75
  76         public <P, H extends AtomicHighLevelStateHandler> H addAtomicHighLevelState(String subcomponentStateID,
  77                         BiFunction<HighLevelStateHandlerContext, P, H> handlerConstructor, P handlerParams)
  78         {
  79                 return addAtomicHighLevelState(subcomponentStateID, c -> handlerConstructor.apply(c, handlerParams));
  80         }
  81
  82         public <H extends AtomicHighLevelStateHandler> H addAtomicHighLevelState(String subcomponentStateID,
  83                         Function<HighLevelStateHandlerContext, H> handlerConstructor)
  84         {
  85                 HighLevelStateHandlerContext context = new HighLevelStateHandlerContext(component, subcomponentStateID);
  86                 H handler = handlerConstructor.apply(context);
  87                 addAtomicHighLevelState(subcomponentStateID, handler);
  88                 return handler;
  89         }
  90
  91         public void addAtomicHighLevelState(String atomicStateID, AtomicHighLevelStateHandler handler)
  92         {
  93                 checkHighLevelStateIDPart(atomicStateID);
  94                 atomicHighLevelStateHandlers.put(atomicStateID, handler);
  95         }
  96
  97         private static void checkHighLevelStateIDPart(String stateIDPart)
  98         {
  99                 if (stateIDPart.indexOf('.') != -1)
 100                         throw new IllegalArgumentException("Illegal high level state ID part (contains dot): " + stateIDPart);
 101         }
 102
 103         @Override
 104         public Object getHighLevelState(String stateID)
 105         {
 106                 int indexOfDot = stateID.indexOf('.');
 107                 if (indexOfDot == -1)
 108                 {
 109                         AtomicHighLevelStateHandler handler = atomicHighLevelStateHandlers.get(stateID);
 110                         if (handler != null)
 111                                 return handler.getHighLevelState();
 112                 } else
 113                 {
 114                         SubcomponentHighLevelStateHandler handler = subcomponentHighLevelStateHandlers.get(stateID.substring(0, indexOfDot));
 115                         if (handler != null)
 116                                 return handler.getHighLevelState(stateID.substring(indexOfDot + 1));
 117                 }
 118                 throw new IllegalArgumentException("No high level state with ID " + stateID);
 119         }
 120
 121         @Override
 122         public void setHighLevelState(String stateID, Object newState)
 123         {
 124                 int indexOfDot = stateID.indexOf('.');
 125                 if (indexOfDot == -1)
 126                 {
 127                         AtomicHighLevelStateHandler handler = atomicHighLevelStateHandlers.get(stateID);
 128                         if (handler != null)
 129                                 handler.setHighLevelState(newState);
 130                         else
 131                                 throw new IllegalArgumentException("No high level state with ID " + stateID);
 132                 } else
 133                 {
 134                         SubcomponentHighLevelStateHandler handler = subcomponentHighLevelStateHandlers.get(stateID.substring(0, indexOfDot));
 135                         if (handler != null)
 136                                 handler.setHighLevelState(stateID.substring(indexOfDot + 1), newState);
 137                         else
 138                                 throw new IllegalArgumentException("No high level state with ID " + stateID);
 139                 }
 140         }
 141
 142         public static class StandardHighLevelStateHandlerParams
 143         {
 144                 public Map<String, SubcomponentHighLevelStateHandlerParams> subcomponentHighLevelStates;
 145                 public Map<String, AtomicHighLevelStateHandlerParams> atomicHighLevelStates;
 146         }
 147
 148         static
 149         {
 150                 SubmodelComponentSnippetSuppliers.highLevelStateHandlerSupplier.setSnippetSupplier(
 151                                 StandardHighLevelStateHandler.class.getCanonicalName(),
 152                                 SnippetDefinintion.create(StandardHighLevelStateHandlerParams.class, StandardHighLevelStateHandler::new));
 153         }
 154 }