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