001package jmri.jmrit.logixng.implementation; 002 003import java.util.ArrayList; 004import java.util.HashMap; 005import java.util.List; 006import java.util.Map; 007import java.util.ServiceLoader; 008 009import javax.annotation.Nonnull; 010 011import jmri.*; 012import jmri.jmrit.logixng.*; 013import jmri.util.*; 014 015/** 016 * Class providing the basic logic of the DigitalExpressionManager interface. 017 * 018 * @author Dave Duchamp Copyright (C) 2007 019 * @author Daniel Bergqvist Copyright (C) 2018 020 */ 021public class DefaultDigitalExpressionManager extends AbstractBaseManager<MaleDigitalExpressionSocket> 022 implements DigitalExpressionManager, InstanceManagerAutoDefault { 023 024 private final Map<Category, List<Class<? extends Base>>> expressionClassList = new HashMap<>(); 025 private MaleSocket _lastRegisteredBean; 026 027 028 public DefaultDigitalExpressionManager() { 029 InstanceManager.getDefault(LogixNG_Manager.class).registerManager(this); 030 031 for (DigitalExpressionFactory expressionFactory : ServiceLoader.load(DigitalExpressionFactory.class)) { 032 expressionFactory.init(); 033 } 034 035 for (Category category : Category.values()) { 036 expressionClassList.put(category, new ArrayList<>()); 037 } 038 039// System.out.format("Read expressions%n"); 040 for (DigitalExpressionFactory expressionFactory : ServiceLoader.load(DigitalExpressionFactory.class)) { 041 expressionFactory.getExpressionClasses().forEach((entry) -> { 042// System.out.format("Add expression: %s, %s%n", entry.getKey().name(), entry.getValue().getName()); 043 expressionClassList.get(entry.getKey()).add(entry.getValue()); 044 }); 045 } 046 047 for (MaleDigitalExpressionSocketFactory maleSocketFactory : ServiceLoader.load(MaleDigitalExpressionSocketFactory.class)) { 048 _maleSocketFactories.add(maleSocketFactory); 049 } 050 } 051 052 /** {@inheritDoc} */ 053 @Override 054 public Class<? extends MaleSocket> getMaleSocketClass() { 055 return DefaultMaleDigitalExpressionSocket.class; 056 } 057 058 protected MaleDigitalExpressionSocket createMaleExpressionSocket(DigitalExpressionBean expression) { 059 MaleDigitalExpressionSocket socket = new DefaultMaleDigitalExpressionSocket(this, expression); 060 expression.setParent(socket); 061 return socket; 062 } 063 064 /** {@inheritDoc} */ 065 @Override 066 public MaleSocket getLastRegisteredMaleSocket() { 067 return _lastRegisteredBean; 068 } 069 070 /** {@inheritDoc} */ 071 @Override 072 public MaleDigitalExpressionSocket registerBean(MaleDigitalExpressionSocket maleSocket) { 073 MaleDigitalExpressionSocket bean = super.registerBean(maleSocket); 074 _lastRegisteredBean = maleSocket; 075 return bean; 076 } 077 078 /** 079 * Remember a NamedBean Object created outside the manager. 080 * This method creates a MaleActionSocket for the action. 081 * 082 * @param expression the bean 083 */ 084 @Override 085 public MaleDigitalExpressionSocket registerExpression(@Nonnull DigitalExpressionBean expression) 086 throws IllegalArgumentException { 087 088 if (expression instanceof MaleDigitalExpressionSocket) { 089 throw new IllegalArgumentException("registerExpression() cannot register a MaleDigitalExpressionSocket. Use the method register() instead."); 090 } 091 092 // Check if system name is valid 093 if (this.validSystemNameFormat(expression.getSystemName()) != NameValidity.VALID) { 094 log.warn("SystemName {} is not in the correct format", expression.getSystemName() ); 095 throw new IllegalArgumentException("System name is invalid: "+expression.getSystemName()); 096 } 097 098 // Keep track of the last created auto system name 099 updateAutoNumber(expression.getSystemName()); 100 101 // save in the maps 102 MaleDigitalExpressionSocket maleSocket = createMaleExpressionSocket(expression); 103 return registerBean(maleSocket); 104 } 105 106 @Override 107 public int getXMLOrder() { 108 return LOGIXNG_DIGITAL_EXPRESSIONS; 109 } 110 111 @Override 112 public char typeLetter() { 113 return 'Q'; 114 } 115 116 /*.* 117 * Test if parameter is a properly formatted system name. 118 * 119 * @param systemName the system name 120 * @return enum indicating current validity, which might be just as a prefix 121 *./ 122 @Override 123 public NameValidity validSystemNameFormat(String systemName) { 124 return LogixNG_Manager.validSystemNameFormat( 125 getSubSystemNamePrefix(), systemName); 126 } 127*/ 128 @Override 129 public FemaleDigitalExpressionSocket createFemaleSocket( 130 Base parent, FemaleSocketListener listener, String socketName) { 131 132 return new DefaultFemaleDigitalExpressionSocket(parent, listener, socketName); 133 } 134 135 @Override 136 public Map<Category, List<Class<? extends Base>>> getExpressionClasses() { 137 return expressionClassList; 138 } 139 140 /** {@inheritDoc} */ 141 @Override 142 public String getBeanTypeHandled(boolean plural) { 143 return Bundle.getMessage(plural ? "BeanNameDigitalExpressions" : "BeanNameDigitalExpression"); 144 } 145 146 /** {@inheritDoc} */ 147 @Override 148 public void deleteDigitalExpression(MaleDigitalExpressionSocket x) { 149 // delete the MaleDigitalExpressionSocket 150 deregister(x); 151 x.dispose(); 152 } 153 154 static volatile DefaultDigitalExpressionManager _instance = null; 155 156 @InvokeOnGuiThread // this method is not thread safe 157 static public DefaultDigitalExpressionManager instance() { 158 if (!ThreadingUtil.isGUIThread()) { 159 LoggingUtil.warnOnce(log, "instance() called on wrong thread"); 160 } 161 162 if (_instance == null) { 163 _instance = new DefaultDigitalExpressionManager(); 164 } 165 return (_instance); 166 } 167 168 @Override 169 public Class<MaleDigitalExpressionSocket> getNamedBeanClass() { 170 return MaleDigitalExpressionSocket.class; 171 } 172 173 @Override 174 protected MaleDigitalExpressionSocket castBean(MaleSocket maleSocket) { 175 return (MaleDigitalExpressionSocket)maleSocket; 176 } 177 178 179 private final static org.slf4j.Logger log = org.slf4j.LoggerFactory.getLogger(DefaultDigitalExpressionManager.class); 180 181}