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.Collections;
   4 import java.util.HashMap;
   5 import java.util.Map;
   6 import java.util.Map.Entry;
   7 import java.util.function.BiFunction;
   8 import java.util.function.Function;
   9
  10 import net.mograsim.logic.model.model.components.submodels.SubmodelComponent;
  11 import net.mograsim.logic.model.serializing.IdentifyParams;
  12 import net.mograsim.logic.model.snippets.HighLevelStateHandler;
  13 import net.mograsim.logic.model.snippets.SnippetDefinintion;
  14 import net.mograsim.logic.model.snippets.SubmodelComponentSnippetSuppliers;
  15 import net.mograsim.logic.model.snippets.highlevelstatehandlers.standard.atomic.AtomicHighLevelStateHandler;
  16 import net.mograsim.logic.model.snippets.highlevelstatehandlers.standard.atomic.AtomicHighLevelStateHandler.AtomicHighLevelStateHandlerParams;
  17 import net.mograsim.logic.model.snippets.highlevelstatehandlers.standard.subcomponent.SubcomponentHighLevelStateHandler;
  18 import net.mograsim.logic.model.snippets.highlevelstatehandlers.standard.subcomponent.SubcomponentHighLevelStateHandler.SubcomponentHighLevelStateHandlerParams;
  19
  20 public class StandardHighLevelStateHandler implements HighLevelStateHandler
  21 {
  22         private final SubmodelComponent component;
  23         private final Map<String, SubcomponentHighLevelStateHandler> subcomponentHighLevelStateHandlers;
  24         private final Map<String, SubcomponentHighLevelStateHandler> subcomponentHighLevelStateHandlersUnmodifiable;
  25         private final Map<String, AtomicHighLevelStateHandler> atomicHighLevelStateHandlers;
  26         private final Map<String, AtomicHighLevelStateHandler> atomicHighLevelStateHandlersUnmodifiable;
  27
  28         public StandardHighLevelStateHandler(SubmodelComponent component)
  29         {
  30                 this(component, null);
  31         }
  32
  33         public StandardHighLevelStateHandler(SubmodelComponent component, StandardHighLevelStateHandlerParams params)
  34         {
  35                 this.component = component;
  36                 this.subcomponentHighLevelStateHandlers = new HashMap<>();
  37                 this.subcomponentHighLevelStateHandlersUnmodifiable = Collections.unmodifiableMap(subcomponentHighLevelStateHandlers);
  38                 this.atomicHighLevelStateHandlers = new HashMap<>();
  39                 this.atomicHighLevelStateHandlersUnmodifiable = Collections.unmodifiableMap(atomicHighLevelStateHandlers);
  40                 if (params != null)
  41                 {
  42                         params.subcomponentHighLevelStates.forEach(this::addSubcomponentHighLevelState);
  43                         params.atomicHighLevelStates.forEach(this::addAtomicHighLevelState);
  44                 }
  45         }
  46
  47         public SubcomponentHighLevelStateHandler addSubcomponentHighLevelState(String subcomponentStateID,
  48                         SubcomponentHighLevelStateHandlerParams handlerParams)
  49         {
  50                 return addSubcomponentHighLevelState(subcomponentStateID,
  51                                 StandardHighLevelStateHandlerSnippetSuppliers.subcomponentHandlerSupplier.getSnippetSupplier(handlerParams.id)::create,
  52                                 handlerParams.params);
  53         }
  54
  55         public <P, H extends SubcomponentHighLevelStateHandler> H addSubcomponentHighLevelState(String subcomponentStateID,
  56                         BiFunction<HighLevelStateHandlerContext, P, H> handlerConstructor, P handlerParams)
  57         {
  58                 return addSubcomponentHighLevelState(subcomponentStateID, c -> handlerConstructor.apply(c, handlerParams));
  59         }
  60
  61         public <H extends SubcomponentHighLevelStateHandler> H addSubcomponentHighLevelState(String subcomponentStateID,
  62                         Function<HighLevelStateHandlerContext, H> handlerConstructor)
  63         {
  64                 HighLevelStateHandlerContext context = new HighLevelStateHandlerContext(component, subcomponentStateID);
  65                 H handler = handlerConstructor.apply(context);
  66                 addSubcomponentHighLevelState(subcomponentStateID, handler);
  67                 return handler;
  68         }
  69
  70         public void addSubcomponentHighLevelState(String subcomponentStateID, SubcomponentHighLevelStateHandler handler)
  71         {
  72                 checkHighLevelStateIDPart(subcomponentStateID);
  73                 subcomponentHighLevelStateHandlers.put(subcomponentStateID, handler);
  74         }
  75
  76         public void removeSubcomponentHighLevelState(String subcomponentStateID)
  77         {
  78                 checkHighLevelStateIDPart(subcomponentStateID);
  79                 subcomponentHighLevelStateHandlers.remove(subcomponentStateID);
  80         }
  81
  82         public Map<String, SubcomponentHighLevelStateHandler> getSubcomponentHighLevelStates()
  83         {
  84                 return subcomponentHighLevelStateHandlersUnmodifiable;
  85         }
  86
  87         public AtomicHighLevelStateHandler addAtomicHighLevelState(String atomicStateID, AtomicHighLevelStateHandlerParams handlerParams)
  88         {
  89                 return addAtomicHighLevelState(atomicStateID,
  90                                 StandardHighLevelStateHandlerSnippetSuppliers.atomicHandlerSupplier.getSnippetSupplier(handlerParams.id)::create,
  91                                 handlerParams.params);
  92         }
  93
  94         public <P, H extends AtomicHighLevelStateHandler> H addAtomicHighLevelState(String subcomponentStateID,
  95                         BiFunction<HighLevelStateHandlerContext, P, H> handlerConstructor, P handlerParams)
  96         {
  97                 return addAtomicHighLevelState(subcomponentStateID, c -> handlerConstructor.apply(c, handlerParams));
  98         }
  99
 100         public <H extends AtomicHighLevelStateHandler> H addAtomicHighLevelState(String subcomponentStateID,
 101                         Function<HighLevelStateHandlerContext, H> handlerConstructor)
 102         {
 103                 HighLevelStateHandlerContext context = new HighLevelStateHandlerContext(component, subcomponentStateID);
 104                 H handler = handlerConstructor.apply(context);
 105                 addAtomicHighLevelState(subcomponentStateID, handler);
 106                 return handler;
 107         }
 108
 109         public void addAtomicHighLevelState(String atomicStateID, AtomicHighLevelStateHandler handler)
 110         {
 111                 checkHighLevelStateIDPart(atomicStateID);
 112                 atomicHighLevelStateHandlers.put(atomicStateID, handler);
 113         }
 114
 115         public void removeAtomicHighLevelState(String atomicStateID)
 116         {
 117                 checkHighLevelStateIDPart(atomicStateID);
 118                 atomicHighLevelStateHandlers.remove(atomicStateID);
 119         }
 120
 121         public Map<String, AtomicHighLevelStateHandler> getAtomicHighLevelStates()
 122         {
 123                 return atomicHighLevelStateHandlersUnmodifiable;
 124         }
 125
 126         private static void checkHighLevelStateIDPart(String stateIDPart)
 127         {
 128                 if (stateIDPart.indexOf('.') != -1)
 129                         throw new IllegalArgumentException("Illegal high level state ID part (contains dot): " + stateIDPart);
 130         }
 131
 132         @Override
 133         public Object getHighLevelState(String stateID)
 134         {
 135                 int indexOfDot = stateID.indexOf('.');
 136                 if (indexOfDot == -1)
 137                 {
 138                         AtomicHighLevelStateHandler handler = atomicHighLevelStateHandlers.get(stateID);
 139                         if (handler != null)
 140                                 return handler.getHighLevelState();
 141                 } else
 142                 {
 143                         SubcomponentHighLevelStateHandler handler = subcomponentHighLevelStateHandlers.get(stateID.substring(0, indexOfDot));
 144                         if (handler != null)
 145                                 return handler.getHighLevelState(stateID.substring(indexOfDot + 1));
 146                 }
 147                 throw new IllegalArgumentException("No high level state with ID " + stateID);
 148         }
 149
 150         @Override
 151         public void setHighLevelState(String stateID, Object newState)
 152         {
 153                 int indexOfDot = stateID.indexOf('.');
 154                 if (indexOfDot == -1)
 155                 {
 156                         AtomicHighLevelStateHandler handler = atomicHighLevelStateHandlers.get(stateID);
 157                         if (handler != null)
 158                                 handler.setHighLevelState(newState);
 159                         else
 160                                 throw new IllegalArgumentException("No high level state with ID " + stateID);
 161                 } else
 162                 {
 163                         SubcomponentHighLevelStateHandler handler = subcomponentHighLevelStateHandlers.get(stateID.substring(0, indexOfDot));
 164                         if (handler != null)
 165                                 handler.setHighLevelState(stateID.substring(indexOfDot + 1), newState);
 166                         else
 167                                 throw new IllegalArgumentException("No high level state with ID " + stateID);
 168                 }
 169         }
 170
 171         @Override
 172         public String getIDForSerializing(IdentifyParams idParams)
 173         {
 174                 return "standard";
 175         }
 176
 177         @Override
 178         public StandardHighLevelStateHandlerParams getParamsForSerializing(IdentifyParams idParams)
 179         {
 180                 StandardHighLevelStateHandlerParams params = new StandardHighLevelStateHandlerParams();
 181                 params.subcomponentHighLevelStates = new HashMap<>();
 182                 params.atomicHighLevelStates = new HashMap<>();
 183                 for (Entry<String, SubcomponentHighLevelStateHandler> e : subcomponentHighLevelStateHandlers.entrySet())
 184                 {
 185                         String stateID = e.getKey();
 186                         SubcomponentHighLevelStateHandler handler = e.getValue();
 187                         SubcomponentHighLevelStateHandlerParams handlerParams = new SubcomponentHighLevelStateHandlerParams();
 188                         handlerParams.id = handler.getIDForSerializing(idParams);
 189                         handlerParams.params = handler.getParamsForSerializingJSON(idParams);
 190                         params.subcomponentHighLevelStates.put(stateID, handlerParams);
 191                 }
 192                 for (Entry<String, AtomicHighLevelStateHandler> e : atomicHighLevelStateHandlers.entrySet())
 193                 {
 194                         String stateID = e.getKey();
 195                         AtomicHighLevelStateHandler handler = e.getValue();
 196                         AtomicHighLevelStateHandlerParams handlerParams = new AtomicHighLevelStateHandlerParams();
 197                         handlerParams.id = handler.getIDForSerializing(idParams);
 198                         handlerParams.params = handler.getParamsForSerializingJSON(idParams);
 199                         params.atomicHighLevelStates.put(stateID, handlerParams);
 200                 }
 201                 return params;
 202         }
 203
 204         public static class StandardHighLevelStateHandlerParams
 205         {
 206                 public Map<String, SubcomponentHighLevelStateHandlerParams> subcomponentHighLevelStates;
 207                 public Map<String, AtomicHighLevelStateHandlerParams> atomicHighLevelStates;
 208         }
 209
 210         static
 211         {
 212                 SubmodelComponentSnippetSuppliers.highLevelStateHandlerSupplier.setSnippetSupplier(
 213                                 StandardHighLevelStateHandler.class.getCanonicalName(),
 214                                 SnippetDefinintion.create(StandardHighLevelStateHandlerParams.class, StandardHighLevelStateHandler::new));
 215         }
 216 }