plugins/net.mograsim.machine/src/net/mograsim/machine/MachineRegistry.java

   1 package net.mograsim.machine;
   2
   3 import java.util.Arrays;
   4 import java.util.Collections;
   5 import java.util.HashMap;
   6 import java.util.HashSet;
   7 import java.util.Map;
   8 import java.util.Objects;
   9 import java.util.Set;
  10
  11 import org.eclipse.core.runtime.CoreException;
  12 import org.eclipse.core.runtime.IConfigurationElement;
  13 import org.eclipse.core.runtime.IExtension;
  14 import org.eclipse.core.runtime.IExtensionPoint;
  15 import org.eclipse.core.runtime.IExtensionRegistry;
  16 import org.eclipse.core.runtime.IRegistryEventListener;
  17 import org.eclipse.core.runtime.Platform;
  18
  19 /**
  20  * The MachineRegsitry is a static context registry for all {@link MachineDefinition}s known at any point during runtime.
  21  * <p>
  22  * It is updated automatically as mograsim machine definition extension points ({@link #MACHINE_EXT_ID}) are added or removed.
  23  *
  24  * @author Christian Femers
  25  *
  26  */
  27 public class MachineRegistry
  28 {
  29
  30         public static final String MACHINE_EXT_ID = "net.mograsim.machine.machine_definition";
  31
  32         private static final Map<String, MachineDefinition> installedMachines = Collections.synchronizedMap(new HashMap<>());
  33         private static final Set<MachineRegistryListener> listeners = Collections.synchronizedSet(new HashSet<>());
  34
  35         private static void reload()
  36         {
  37                 installedMachines.clear();
  38                 IExtensionRegistry registry = Platform.getExtensionRegistry();
  39                 System.out.println(Arrays.toString(registry.getExtensionPoints("net.mograsim.machine")));
  40                 IConfigurationElement[] config = registry.getConfigurationElementsFor(MACHINE_EXT_ID);
  41                 try
  42                 {
  43                         for (IConfigurationElement e : config)
  44                         {
  45                                 System.out.println(e.getNamespaceIdentifier());
  46                                 System.out.println(Arrays.toString(e.getAttributeNames()));
  47                                 final Object o = e.createExecutableExtension("class");
  48                                 final String id = e.getAttribute("unique_id");
  49                                 if (o instanceof MachineDefinition)
  50                                 {
  51                                         System.out.println("Found " + id);
  52                                         MachineDefinition md = (MachineDefinition) o;
  53                                         if (Objects.equals(id, md.getId()))
  54                                                 installedMachines.put(id, md);
  55                                         else
  56                                                 System.err.println("Machine definition ids to not match: " + id + " and " + md.getId());
  57                                 } else
  58                                 {
  59                                         System.err.println("Invalid machine definition: " + o + "(id=" + id + "");
  60                                 }
  61                         }
  62                 }
  63                 catch (CoreException ex)
  64                 {
  65                         System.out.println(ex.getMessage());
  66                 }
  67                 notifyListeners();
  68         }
  69
  70         public static void initialize()
  71         {
  72                 reload();
  73                 Platform.getExtensionRegistry().addListener(new IRegistryEventListener()
  74                 {
  75
  76                         @Override
  77                         public void removed(IExtensionPoint[] extensionPoints)
  78                         {
  79                                 // nothing?
  80                         }
  81
  82                         @Override
  83                         public void removed(IExtension[] extensions)
  84                         {
  85                                 reload();
  86                         }
  87
  88                         @Override
  89                         public void added(IExtensionPoint[] extensionPoints)
  90                         {
  91                                 // nothing?
  92                         }
  93
  94                         @Override
  95                         public void added(IExtension[] extensions)
  96                         {
  97                                 reload();
  98                         }
  99                 }, MACHINE_EXT_ID);
 100         }
 101
 102         public static Map<String, MachineDefinition> getInstalledMachines()
 103         {
 104                 return Collections.unmodifiableMap(installedMachines);
 105         }
 106
 107         public static MachineDefinition getMachine(String id)
 108         {
 109                 return installedMachines.get(id);
 110         }
 111
 112         private static void notifyListeners()
 113         {
 114                 Map<String, MachineDefinition> unmodMachines = getInstalledMachines();
 115                 listeners.forEach(l -> l.onReload(unmodMachines));
 116         }
 117
 118         public static void addMachineRegistryListener(MachineRegistryListener listener)
 119         {
 120                 listeners.add(listener);
 121         }
 122
 123         public static void removeMachineRegistryListener(MachineRegistryListener listener)
 124         {
 125                 listeners.remove(listener);
 126         }
 127
 128         @FunctionalInterface
 129         public interface MachineRegistryListener
 130         {
 131                 void onReload(Map<String, MachineDefinition> installedMachines);
 132         }
 133 }