GenericContainer.java

Violations

Source code

package biz.hammurapi.config;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

import biz.hammurapi.metrics.MeasurementCollector;
import biz.hammurapi.metrics.MeasurementConsumer;
import biz.hammurapi.util.Attributable;
import biz.hammurapi.util.CollectionVisitable;
import biz.hammurapi.util.VisitableBase;
import biz.hammurapi.util.Visitor;

public class GenericContainer extends VisitableBase implements Component, Command, Attributable, Context, MeasurementCollector, MeasurementConsumer {

	private Map componentMap = new LinkedHashMap();

	protected Map getComponentMap() {
		return componentMap;
	}

	private boolean started;
	private Object owner;
	
	private PathNavigator pathNavigator = new PathNavigator(this) {
	
			protected Object getParent() {
				return owner;
			}
	
			protected Object getChild(String name) {
				return componentMap.get(name);
			}
			
		};
		
	private LinkedHashMap attributes = new LinkedHashMap();
	private MeasurementConsumer measurementConsumer;

	/**
	 * Looks up component in component tree.
	 * @param name
	 * @return
	 */
	public Object get(String name) {		
		return pathNavigator.get(name);
	}

	/**
	 * Adds component and starts it.
	 * @param name
	 * @param component
	 * @throws ConfigurationException
	 */
	public void addComponent(String name, Object component) throws ConfigurationException {
		if (name==null) {
			name = "Anonymous component "+componentMap.size();
		}
		
		// Remove previous component

		Object prevComponent=componentMap.remove(name);
		if (prevComponent!=null) {
			if (prevComponent instanceof Component) {
				if (started) {
					((Component) prevComponent).stop();
				}
				((Component) prevComponent).setOwner(null);
			}
			
			if (prevComponent instanceof MeasurementCollector) {
				((MeasurementCollector) prevComponent).setMeasurementConsumer(null);
			}
		}
		
		if (component!=null) {
			if (component instanceof MeasurementCollector) {
				final String componentName = name;
				MeasurementConsumer cmc = new MeasurementConsumer() {
					public void addMeasurement(String mName, double value, long time) {
						if (measurementConsumer!=null) {
							measurementConsumer.addMeasurement(componentName+"."+mName, value, time==0 ? System.currentTimeMillis() : time);
						}						
					}
				};
				((MeasurementCollector) component).setMeasurementConsumer(cmc);
			}
			
			if (component instanceof NamedComponent) {
				((NamedComponent) component).setName(name);
			}
			
			// Add new component

			if (component instanceof Component) {
				Component theComponent = (Component) component;
				theComponent.setOwner(this);
				if (started) {
					theComponent.start();
				}
			}
	
			if (name!=null) {
				componentMap.put(name, component);
			}
			
		}
	}

	public void start() throws ConfigurationException {
		if (getMeasurementConsumer() instanceof Component) {
			((Component) getMeasurementConsumer()).start();
		}
		
		Iterator it=componentMap.values().iterator();
		while (it.hasNext()) {
			Object component = it.next();
			if (component instanceof Component) {
				((Component) component).start();
			}			
		}
		started=true;
	}

	public void stop() throws ConfigurationException {
		started=false;
		List reverseComponentList=new ArrayList(componentMap.values());
		Collections.reverse(reverseComponentList);
		Iterator it=reverseComponentList.iterator();
		while (it.hasNext()) {
			Object component = it.next();
			if (component instanceof Component) {
				((Component) component).stop();
			}			
		}
		if (getMeasurementConsumer() instanceof Component) {
			((Component) getMeasurementConsumer()).stop();
		}
	}

	public void setOwner(Object owner) {
		this.owner=owner;		
	}

	/**
	 * Invokes execute() of executable components sequentially.
	 */
	public void execute(Object executionContext) {
		Iterator it=componentMap.values().iterator();
		while (it.hasNext()) {
			Object component = it.next();
			if (component instanceof Command) {
				((Command) component).execute(executionContext);
			}			
		}
	}

	protected void acceptChildren(Visitor visitor) {
		new CollectionVisitable(componentMap.values(), false).accept(visitor);
	}

	protected Collection getComponents() {
		return componentMap.values();
	}

	public Set getComponentNames() {
		return Collections.unmodifiableSet(componentMap.keySet());
	}

	public void setAttribute(Object key, Object value) {
		attributes.put(key, value);
	}

	public Object getAttribute(Object key) {
		return attributes.get(key);
	}

	public Object removeAttribute(Object key) {
		return attributes.remove(key);
	}

	public void setMeasurementConsumer(MeasurementConsumer measurementConsumer) {
		this.measurementConsumer = measurementConsumer;		
		if (measurementConsumer instanceof Component) {
			((Component) measurementConsumer).setOwner(this);
		}
	}
	
	public MeasurementConsumer getMeasurementConsumer() {
		return measurementConsumer;
	}

	public void addMeasurement(String name, double value, long time) {
		if (measurementConsumer!=null) {
			measurementConsumer.addMeasurement(name, value, time);
		}		
	}		

	/**
	 * Finds component owner of particular type.
	 * @param ownerType
	 * @return Owner which is an instance of specified type or null if no such owner is found.
	 */
	public Object getOwner(Class ownerType) {
		if (owner==null || ownerType.isInstance(owner)) {
			return owner;
		}
		
		if (owner instanceof ComponentBase) {
			return ((ComponentBase) owner).getOwner(ownerType);
		}
		
		if (owner instanceof GenericContainer) {
			return ((GenericContainer) owner).getOwner(ownerType);
		}
		
		return null;
	}
}