Java tutorial
/* * Created on Oct 21, 2006 Copyright (C) 2001-6, Anthony Harrison anh23@pitt.edu * (jactr.org) This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public License as * published by the Free Software Foundation; either version 2.1 of the License, * or (at your option) any later version. This library is distributed in the * hope that it will be useful, but WITHOUT ANY WARRANTY; without even the * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See * the GNU Lesser General Public License for more details. You should have * received a copy of the GNU Lesser General Public License along with this * library; if not, write to the Free Software Foundation, Inc., 59 Temple * Place, Suite 330, Boston, MA 02111-1307 USA */ package org.jactr.core.model.basic; import java.util.ArrayList; import java.util.Arrays; import java.util.Collection; import java.util.Collections; import java.util.Map; import java.util.TreeMap; import java.util.TreeSet; import java.util.concurrent.Executor; import java.util.concurrent.locks.ReentrantReadWriteLock; import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.jactr.core.buffer.IActivationBuffer; import org.jactr.core.event.ACTREventDispatcher; import org.jactr.core.event.IParameterListener; import org.jactr.core.event.ParameterEvent; import org.jactr.core.extensions.IExtension; import org.jactr.core.model.ICycleProcessor; import org.jactr.core.model.IModel; import org.jactr.core.model.IllegalModelStateException; import org.jactr.core.model.event.IModelListener; import org.jactr.core.model.event.ModelEvent; import org.jactr.core.model.six.DefaultCycleProcessor6; import org.jactr.core.module.IModule; import org.jactr.core.module.declarative.IDeclarativeModule; import org.jactr.core.module.procedural.IProceduralModule; import org.jactr.core.queue.TimedEventQueue; import org.jactr.core.runtime.ACTRRuntime; import org.jactr.core.utils.collections.CachedCollection; import org.jactr.core.utils.collections.CachedMap; import org.jactr.core.utils.parameter.IParameterized; import org.jactr.core.utils.parameter.ParameterHandler; import org.jactr.instrument.IInstrument; public class BasicModel implements IModel { /** * logger definition */ static private final Log LOGGER = LogFactory.getLog(BasicModel.class); static public final String CYCLE_SKIPPING_PARAM = "EnableUnusedCycleSkipping"; static public final String PERSISTENT_PARAM = "EnablePersistentExecution"; static public final String AGE_PARAM = "Age"; static private final Collection<String> READABLE_PARAMETERS = Collections .unmodifiableCollection(Arrays.asList(AGE_PARAM, CYCLE_SKIPPING_PARAM, PERSISTENT_PARAM)); static private final Collection<String> WRITABLE_PARAMETERS = Collections .unmodifiableCollection(Arrays.asList(AGE_PARAM, CYCLE_SKIPPING_PARAM, PERSISTENT_PARAM)); protected boolean _isInitialized = false; protected TimedEventQueue _timedEventQueue; protected IDeclarativeModule _declarativeModule; protected IProceduralModule _proceduralModule; protected CachedMap<String, IActivationBuffer> _buffers; protected CachedCollection<IModule> _modules; protected CachedCollection<IExtension> _extensions; protected CachedCollection<IInstrument> _installedInstruments; protected boolean _cycleSkippingEnabled = true; protected boolean _persistentExecution = false; protected ReentrantReadWriteLock _lock = new ReentrantReadWriteLock(); protected ACTREventDispatcher<IModel, IModelListener> _eventDispatcher; protected ACTREventDispatcher<IParameterized, IParameterListener> _parameterEventDispatcher; protected Map<String, Object> _metaData; protected Map<String, Object> _parameterMap; protected String _name; protected boolean _modulesInitialized = false; protected long _cycle; protected double _age; protected ICycleProcessor _cycleProcessor; public BasicModel() { _timedEventQueue = new TimedEventQueue(this); _buffers = new CachedMap<String, IActivationBuffer>(new TreeMap<String, IActivationBuffer>()); _modules = new CachedCollection<IModule>(new ArrayList<IModule>()); _extensions = new CachedCollection<IExtension>(new ArrayList<IExtension>()); _installedInstruments = new CachedCollection<IInstrument>(new ArrayList<IInstrument>()); _eventDispatcher = new ACTREventDispatcher<IModel, IModelListener>(); _parameterEventDispatcher = new ACTREventDispatcher<IParameterized, IParameterListener>(); _metaData = new TreeMap<String, Object>(); _parameterMap = new TreeMap<String, Object>(); setCycleProcessor(createCycleProcessor()); } public void setCycleProcessor(ICycleProcessor processor) { _cycleProcessor = processor; } public ICycleProcessor getCycleProcessor() { return _cycleProcessor; } protected ICycleProcessor createCycleProcessor() { return new DefaultCycleProcessor6(); } public BasicModel(String name) { this(); setName(name); } public void dispose() { /* * explicitly uninstall */ for (IInstrument instrument : new ArrayList<IInstrument>(_installedInstruments)) uninstall(instrument); /* * modules are responsible for buffer disposal */ for (IModule module : _modules) module.dispose(); try { // acquire lock _lock.writeLock().lock(); /* * no more events */ _eventDispatcher.clear(); _eventDispatcher = null; _extensions.clear(); _extensions = null; _modules.clear(); _modules = null; _buffers.clear(); _buffers = null; _metaData.clear(); _metaData = null; _parameterMap.clear(); _parameterMap = null; _timedEventQueue.dispose(); _timedEventQueue = null; _declarativeModule = null; _proceduralModule = null; } finally { // release _lock.writeLock().unlock(); } } public void addActivationBuffer(IActivationBuffer buffer) { boolean added = false; try { // acquire lock _lock.writeLock().lock(); _buffers.put(buffer.getName().toLowerCase(), buffer); added = true; } finally { // release _lock.writeLock().unlock(); if (added) dispatch(new ModelEvent(this, buffer)); } } public IActivationBuffer getActivationBuffer(String name) { try { // lock _lock.readLock().lock(); return _buffers.get(name.toLowerCase()); } finally { // unlock _lock.readLock().unlock(); } } public Collection<IActivationBuffer> getActivationBuffers() { ArrayList<IActivationBuffer> buffers = new ArrayList<IActivationBuffer>(_buffers.size()); getActivationBuffers(buffers); return buffers; } public void getActivationBuffers(Collection<IActivationBuffer> container) { try { // lock _lock.readLock().lock(); _buffers.getValues(container); } finally { // unlock _lock.readLock().unlock(); } } public IDeclarativeModule getDeclarativeModule() { try { // lock _lock.readLock().lock(); return _declarativeModule; } finally { // unlock _lock.readLock().unlock(); } } public IExtension getExtension(Class<? extends IExtension> extensionClass) { try { // lock _lock.readLock().lock(); for (IExtension extension : _extensions) if (extensionClass.isAssignableFrom(extension.getClass())) return extension; return null; } finally { // unlock _lock.readLock().unlock(); } } public Collection<IExtension> getExtensions() { try { // lock _lock.readLock().lock(); return Collections.unmodifiableCollection(_extensions); } finally { // unlock _lock.readLock().unlock(); } } public IInstrument getInstrument(Class<? extends IInstrument> instrumentClass) { try { // lock _lock.readLock().lock(); for (IInstrument installable : _installedInstruments) if (instrumentClass.isAssignableFrom(installable.getClass())) return installable; return null; } finally { // unlock _lock.readLock().unlock(); } } public Collection<IInstrument> getInstruments() { try { // lock _lock.readLock().lock(); return Collections.unmodifiableCollection(_installedInstruments); } finally { // unlock _lock.readLock().unlock(); } } public IModule getModule(Class<? extends IModule> moduleClass) { try { // lock _lock.readLock().lock(); for (IModule module : _modules) if (moduleClass.isAssignableFrom(module.getClass())) return module; return null; } finally { // unlock _lock.readLock().unlock(); } } public Collection<IModule> getModules() { try { // lock _lock.readLock().lock(); return Collections.unmodifiableCollection(_modules); } finally { // unlock _lock.readLock().unlock(); } } public IProceduralModule getProceduralModule() { try { // lock _lock.readLock().lock(); return _proceduralModule; } finally { // unlock _lock.readLock().unlock(); } } public void install(IModule module) { boolean added = false; try { // acquire lock _lock.writeLock().lock(); if (module instanceof IDeclarativeModule) { if (_declarativeModule != null) throw new IllegalModelStateException( "Only one declarative module may exist in a model at a time"); _declarativeModule = (IDeclarativeModule) module; } if (module instanceof IProceduralModule) { if (_proceduralModule != null) throw new IllegalModelStateException( "Only one procedural module may exist in a model at a time"); _proceduralModule = (IProceduralModule) module; } _modules.add(module); added = true; } finally { // release _lock.writeLock().unlock(); if (added) { /* * install out of the lock in case this takes a sig amount of time */ module.install(this); if (hasBeenInitialized()) module.initialize(); dispatch(new ModelEvent(this, module)); } } } public void install(IExtension extension) { if (!modulesAreInitialized()) initializeModules(); boolean added = false; try { // acquire lock _lock.writeLock().lock(); _extensions.add(extension); added = true; } finally { // release _lock.writeLock().unlock(); if (added) { /* * install out of the lock in case this takes a sig amount of time */ extension.install(this); if (hasBeenInitialized()) try { extension.initialize(); } catch (Exception e) { throw new IllegalModelStateException("Exception while initializing extension " + extension, e); } dispatch(new ModelEvent(this, extension)); } } } public void install(IInstrument instrument) { if (!modulesAreInitialized()) initializeModules(); boolean added = false; try { // acquire lock _lock.writeLock().lock(); _installedInstruments.add(instrument); added = true; } finally { // release _lock.writeLock().unlock(); if (added) { /* * perform the instll out of the lock */ instrument.install(this); if (hasBeenInitialized()) instrument.initialize(); dispatch(new ModelEvent(this, instrument)); } } } /** * @see org.jactr.core.model.IModel#uninstall(org.jactr.instrument.IInstrument) */ public void uninstall(IInstrument installable) { try { _lock.writeLock().lock(); _installedInstruments.remove(installable); } finally { _lock.writeLock().unlock(); } /* * pull it out of the lock, since this may take some time */ installable.uninstall(this); } public String getParameter(String key) { if (CYCLE_SKIPPING_PARAM.equalsIgnoreCase(key)) return ParameterHandler.booleanInstance().toString(isCycleSkippingEnabled()); else if (AGE_PARAM.equalsIgnoreCase(key)) return "" + getAge(); else if (PERSISTENT_PARAM.equalsIgnoreCase(key)) return "" + isPersistentExecutionEnabled(); if (_parameterMap.containsKey(key)) return _parameterMap.get(key).toString(); if (LOGGER.isWarnEnabled()) LOGGER.warn("Unknown parameter " + key + " requested, returning null"); return null; } public Collection<String> getPossibleParameters() { TreeSet<String> possible = new TreeSet<String>(READABLE_PARAMETERS); possible.addAll(WRITABLE_PARAMETERS); return possible; } public Collection<String> getSetableParameters() { return WRITABLE_PARAMETERS; } public void setParameter(String key, String value) { boolean handled = false; if (CYCLE_SKIPPING_PARAM.equalsIgnoreCase(key)) { setCycleSkippingEnabled(ParameterHandler.booleanInstance().coerce(value)); handled = true; } else if (AGE_PARAM.equalsIgnoreCase(key)) { setAge(ParameterHandler.numberInstance().coerce(value).doubleValue()); handled = true; } else if (PERSISTENT_PARAM.equalsIgnoreCase(key)) { setPersistentExecutionEnabled(ParameterHandler.booleanInstance().coerce(value)); handled = true; } else // check the modules.. for (IModule module : _modules) if (module instanceof IParameterized) if (((IParameterized) module).getSetableParameters().contains(key)) { // route it if (LOGGER.isWarnEnabled()) LOGGER.warn( "You should not use the model as the parameter nexus, rather assigned it to the module directly"); ((IParameterized) module).setParameter(key, value); handled = true; } if (!handled) { if (LOGGER.isDebugEnabled()) LOGGER.debug("No registered handler for " + key + " = " + value); _parameterMap.put(key, value); } } public Object getMetaData(String key) { try { // lock _lock.readLock().lock(); return _metaData.get(key); } finally { // unlock _lock.readLock().unlock(); } } public void setMetaData(String key, Object value) { try { // acquire lock _lock.writeLock().lock(); _metaData.put(key, value); } finally { // release _lock.writeLock().unlock(); } } public Collection<String> getMetaDataKeys() { return new ArrayList<String>(_metaData.keySet()); } public void setAge(double age) { _age = age; } public double getAge() { return _age; } public void setCycleSkippingEnabled(boolean skipping) { if (skipping == _cycleSkippingEnabled) return; boolean old = _cycleSkippingEnabled; _cycleSkippingEnabled = skipping; fireParameterEvent(CYCLE_SKIPPING_PARAM, old, skipping); } public boolean isCycleSkippingEnabled() { return _cycleSkippingEnabled; } public void setPersistentExecutionEnabled(boolean persistent) { if (_persistentExecution == persistent) return; boolean old = _persistentExecution; _persistentExecution = persistent; fireParameterEvent(PERSISTENT_PARAM, old, persistent); } public boolean isPersistentExecutionEnabled() { return _persistentExecution; } public TimedEventQueue getTimedEventQueue() { return _timedEventQueue; } public boolean hasBeenInitialized() { return _isInitialized; } /** * initialize the model, calling initialize on buffers, and extensions in that * order. this is called before the model starts to run Modules will have * already been initialized, as they are initialized before extensions or * instruments are installed.. * * @see org.jactr.core.model.IModel#initialize() */ public void initialize() throws Exception { if (!modulesAreInitialized()) initializeModules(); try { _lock.writeLock().lock(); if (hasBeenInitialized()) throw new IllegalModelStateException("Model has already been initialized"); _isInitialized = true; for (IActivationBuffer buffer : _buffers.values()) buffer.initialize(); for (IExtension extension : _extensions) extension.initialize(); for (IInstrument instruments : _installedInstruments) instruments.initialize(); } finally { _lock.writeLock().unlock(); dispatch(new ModelEvent(this, ModelEvent.Type.INITIALIZED)); } } protected boolean modulesAreInitialized() { return _modulesInitialized; } protected void initializeModules() { if (modulesAreInitialized()) return; for (IModule module : _modules) module.initialize(); _modulesInitialized = true; } public void addListener(IModelListener listener, Executor executor) { _eventDispatcher.addListener(listener, executor); } public void removeListener(IModelListener listener) { _eventDispatcher.removeListener(listener); } public boolean hasListeners() { return _eventDispatcher.hasListeners(); } public void dispatch(ModelEvent modelEvent) { if (_eventDispatcher.hasListeners()) _eventDispatcher.fire(modelEvent); } public void addListener(IParameterListener listener, Executor executor) { _parameterEventDispatcher.addListener(listener, executor); } public void removeListener(IParameterListener listener) { _parameterEventDispatcher.removeListener(listener); } public boolean hasParameterListeners() { return _parameterEventDispatcher.hasListeners(); } public void dispatch(ParameterEvent modelEvent) { if (_parameterEventDispatcher.hasListeners()) _parameterEventDispatcher.fire(modelEvent); } protected void fireParameterEvent(String parameterName, Object oldValue, Object newValue) { if (hasParameterListeners()) dispatch(new ParameterEvent(this, ACTRRuntime.getRuntime().getClock(this).getTime(), parameterName, oldValue, newValue)); } public String getName() { return _name; } public void setName(String modelName) { _name = modelName; } public long getCycle() { return _cycle; } public void setCycle(long cycle) { if (cycle <= _cycle) return; _cycle = cycle; } @Override public String toString() { return getName(); } }