DefaultPicoContainer.java
| Index Score | ||
|---|---|---|
 |
 |
org.picocontainer |
 |
|
PicoContainer |
View: Reasons, Metrics, Source Code
These are the metrics that contribute to the Enerjy Score for this file, ranked by impact. So the metrics listed at the top influence the score to a greater extent that the metrics listed at the bottom.
| Metric | Description | |
|---|---|---|
| SIZE | Size of the file in bytes |  |
| EXITS | Procedure exits | |
| BLOCKS | Number of blocks | |
| DECL_COMMENTS | Comments in declarations | |
| INTERFACE_COMPLEXITY | Interface complexity | |
| PARAMS | Number of formal parameter declarations | |
| CYCLOMATIC | Cyclomatic complexity | |
| FUNCTIONS | Number of function declarations | |
| RETURNS | Number of return points from functions | |
| UNIQUE_OPERANDS | Number of unique operands | |
| OPERATORS | Number of operators | |
| PROGRAM_VOCAB | Halstead program vocabulary | |
| JAVA0110 | JAVA0110 Incorrect javadoc: no @return tag | |
| PROGRAM_LENGTH | Halstead program length | |
| DOC_COMMENT | Number of javadoc comment lines | |
| LINES | Number of lines in the source file | |
| OPERANDS | Number of operands | |
| LOC | Lines of code | |
| ELOC | Effective lines of code | |
| JAVA0144 | JAVA0144 Line exceeds maximum M characters | |
| COMMENTS | Comment lines | |
| LOGICAL_LINES | Number of statements | |
| COMPARISONS | Number of comparison operators | |
| JAVA0126 | JAVA0126 Method declares unchecked exception in throws | |
| JAVA0034 | JAVA0034 Missing braces in if statement | |
| JAVA0108 | JAVA0108 Incorrect javadoc: no @param tag for 'parameter' | |
| JAVA0081 | JAVA0081 Boolean literal in comparison | |
| JAVA0177 | JAVA0177 Variable declaration missing initializer | |
| UNIQUE_OPERATORS | Number of unique operators | |
| WHITESPACE | Number of whitespace lines | |
| JAVA0075 | JAVA0075 Method parameter hides field | |
| JAVA0132 | JAVA0132 Method overload with compatible signature | |
| JAVA0117 | JAVA0117 Missing javadoc: method 'method' | |
| JAVA0082 | JAVA0082 Unnecessary widening cast | |
| JAVA0128 | JAVA0128 Public constructor in non-public class | |
| NEST_DEPTH | Maximum nesting depth | |
| PROGRAM_VOLUME | Halstead program volume | |
| JAVA0259 | JAVA0259 Return of collection/array field | |
| JAVA0136 | JAVA0136 N methods defined in class (maximum: M) | |
| JAVA0179 | JAVA0179 Local variable hides visible field | |
| EXEC_COMMENTS | Comments in executable code | |
| JAVA0173 | JAVA0173 Unused method parameter | |
| LOOPS | Number of loops | |
| JAVA0044 | JAVA0044 Serializable class with no instance variables | |
| JAVA0130 | JAVA0130 Non-static method does not use instance fields | |
| JAVA0145 | JAVA0145 Tab character used in source file | |
/*****************************************************************************
* Copyright (C) PicoContainer Organization. All rights reserved. *
* ------------------------------------------------------------------------- *
* The software in this package is published under the terms of the BSD *
* style license a copy of which has been included with this distribution in *
* the LICENSE.txt file. *
* *
* Original code by *
*****************************************************************************/
package org.picocontainer;
import java.io.Serializable;
import java.lang.annotation.Annotation;
import java.lang.ref.WeakReference;
import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
import org.picocontainer.adapters.InstanceAdapter;
import org.picocontainer.behaviors.AbstractBehaviorFactory;
import org.picocontainer.behaviors.AdaptingBehavior;
import org.picocontainer.behaviors.Cached;
import org.picocontainer.behaviors.Caching;
import org.picocontainer.behaviors.HiddenImplementation;
import org.picocontainer.containers.AbstractDelegatingMutablePicoContainer;
import org.picocontainer.containers.AbstractDelegatingPicoContainer;
import org.picocontainer.containers.EmptyPicoContainer;
import org.picocontainer.containers.ImmutablePicoContainer;
import org.picocontainer.injectors.AbstractInjector;
import org.picocontainer.injectors.AdaptingInjection;
import org.picocontainer.injectors.FactoryInjector;
import org.picocontainer.lifecycle.DefaultLifecycleState;
import org.picocontainer.lifecycle.LifecycleState;
import org.picocontainer.lifecycle.StartableLifecycleStrategy;
import org.picocontainer.monitors.NullComponentMonitor;
/**
* <p/>
* The Standard {@link PicoContainer}/{@link MutablePicoContainer} implementation.
* Constructing a container c with a parent p container will cause c to look up components
* in p if they cannot be found inside c itself.
* </p>
* <p/>
* Using {@link Class} objects as keys to the various registerXXX() methods makes
* a subtle semantic difference:
* </p>
* <p/>
* If there are more than one registered components of the same type and one of them are
* registered with a {@link java.lang.Class} key of the corresponding type, this addComponent
* will take precedence over other components during type resolution.
* </p>
* <p/>
* Another place where keys that are classes make a subtle difference is in
* {@link HiddenImplementation}.
* </p>
* <p/>
* This implementation of {@link MutablePicoContainer} also supports
* {@link ComponentMonitorStrategy}.
* </p>
*
* @author Paul Hammant
* @author Aslak Hellesøy
* @author Jon Tirsén
* @author Thomas Heller
* @author Mauro Talevi
*/
@SuppressWarnings("serial")
public class DefaultPicoContainer implements MutablePicoContainer, ComponentMonitorStrategy, Serializable {
private String name;
/**
* Component factory instance.
*/
protected final ComponentFactory componentFactory;
/**
* Parent picocontainer
*/
private PicoContainer parent;
/**
* All picocontainer children.
*/
private final Set<PicoContainer> children = new HashSet<PicoContainer>();
/**
* Current state of the container.
*/
private LifecycleState lifecycleState = new DefaultLifecycleState();
/**
* Keeps track of child containers started status.
*/
private final Set<WeakReference<PicoContainer>> childrenStarted = new HashSet<WeakReference<PicoContainer>>();
/**
* Lifecycle strategy instance.
*/
protected final LifecycleStrategy lifecycleStrategy;
private final Properties componentProperties = new Properties();
/**
* Component monitor instance. Receives event callbacks.
*/
protected ComponentMonitor componentMonitor;
/** List collecting the CAs which have been successfully started */
private final List<WeakReference<ComponentAdapter<?>>> startedComponentAdapters = new ArrayList<WeakReference<ComponentAdapter<?>>>();
/**
* Map used for looking up component adapters by their key.
*/
private final Map<Object, ComponentAdapter<?>> componentKeyToAdapterCache = new HashMap<Object, ComponentAdapter<?> >();
private final List<ComponentAdapter<?>> componentAdapters = new ArrayList<ComponentAdapter<?>>();
protected final List<ComponentAdapter<?>> orderedComponentAdapters = new ArrayList<ComponentAdapter<?>>();
private transient IntoThreadLocal intoThreadLocal = new IntoThreadLocal();
/**
* Creates a new container with a custom ComponentFactory and a parent container.
* <p/>
* <em>
* Important note about caching: If you intend the components to be cached, you should pass
* in a factory that creates {@link Cached} instances, such as for example
* {@link Caching}. Caching can delegate to
* other ComponentAdapterFactories.
* </em>
*
* @param componentFactory the factory to use for creation of ComponentAdapters.
* @param parent the parent container (used for component dependency lookups).
*/
public DefaultPicoContainer(final ComponentFactory componentFactory, final PicoContainer parent) {
this(componentFactory, new StartableLifecycleStrategy(new NullComponentMonitor()), parent, new NullComponentMonitor());
}
/**
* Creates a new container with a custom ComponentFactory, LifecycleStrategy for instance registration,
* and a parent container.
* <p/>
* <em>
* Important note about caching: If you intend the components to be cached, you should pass
* in a factory that creates {@link Cached} instances, such as for example
* {@link Caching}. Caching can delegate to
* other ComponentAdapterFactories.
* </em>
*
* @param componentFactory the factory to use for creation of ComponentAdapters.
* @param lifecycleStrategy
* the lifecycle strategy chosen for registered
* instance (not implementations!)
* @param parent the parent container (used for component dependency lookups).
*/
public DefaultPicoContainer(final ComponentFactory componentFactory,
final LifecycleStrategy lifecycleStrategy,
final PicoContainer parent) {
this(componentFactory, lifecycleStrategy, parent, new NullComponentMonitor() );
}
public DefaultPicoContainer(final ComponentFactory componentFactory,
final LifecycleStrategy lifecycleStrategy,
final PicoContainer parent, final ComponentMonitor componentMonitor) {
if (componentFactory == null) {
throw new NullPointerException("componentFactory");
}
if (lifecycleStrategy == null) {
throw new NullPointerException("lifecycleStrategy");
}
this.componentFactory = componentFactory;
this.lifecycleStrategy = lifecycleStrategy;
this.parent = parent;
if (parent != null && !(parent instanceof EmptyPicoContainer)) {
this.parent = new ImmutablePicoContainer(parent);
}
this.componentMonitor = componentMonitor;
}
/**
* Creates a new container with the AdaptingInjection using a
* custom ComponentMonitor
*
* @param monitor the ComponentMonitor to use
* @param parent the parent container (used for component dependency lookups).
*/
public DefaultPicoContainer(final ComponentMonitor monitor, final PicoContainer parent) {
this(new AdaptingBehavior(), new StartableLifecycleStrategy(monitor), parent, monitor);
}
/**
* Creates a new container with the AdaptingInjection using a
* custom ComponentMonitor and lifecycle strategy
*
* @param monitor the ComponentMonitor to use
* @param lifecycleStrategy the lifecycle strategy to use.
* @param parent the parent container (used for component dependency lookups).
*/
public DefaultPicoContainer(final ComponentMonitor monitor, final LifecycleStrategy lifecycleStrategy, final PicoContainer parent) {
this(new AdaptingBehavior(), lifecycleStrategy, parent, monitor);
}
/**
* Creates a new container with the AdaptingInjection using a
* custom lifecycle strategy
*
* @param lifecycleStrategy the lifecycle strategy to use.
* @param parent the parent container (used for component dependency lookups).
*/
public DefaultPicoContainer(final LifecycleStrategy lifecycleStrategy, final PicoContainer parent) {
this(new NullComponentMonitor(), lifecycleStrategy, parent);
}
/**
* Creates a new container with a custom ComponentFactory and no parent container.
*
* @param componentFactory the ComponentFactory to use.
*/
public DefaultPicoContainer(final ComponentFactory componentFactory) {
this(componentFactory, null);
}
/**
* Creates a new container with the AdaptingInjection using a
* custom ComponentMonitor
*
* @param monitor the ComponentMonitor to use
*/
public DefaultPicoContainer(final ComponentMonitor monitor) {
this(monitor, new StartableLifecycleStrategy(monitor), null);
}
/**
* Creates a new container with a (caching) {@link AdaptingInjection}
* and a parent container.
*
* @param parent the parent container (used for component dependency lookups).
*/
public DefaultPicoContainer(final PicoContainer parent) {
this(new AdaptingBehavior(), parent);
}
/** Creates a new container with a {@link AdaptingBehavior} and no parent container. */
public DefaultPicoContainer() {
this(new AdaptingBehavior(), null);
}
/** {@inheritDoc} **/
public Collection<ComponentAdapter<?>> getComponentAdapters() {
return Collections.unmodifiableList(getModifiableComponentAdapterList());
}
/** {@inheritDoc} **/
public final ComponentAdapter<?> getComponentAdapter(final Object componentKey) {
ComponentAdapter<?> adapter = getComponentKeyToAdapterCache().get(componentKey);
if (adapter == null && parent != null) {
adapter = getParent().getComponentAdapter(componentKey);
}
return adapter;
}
/** {@inheritDoc} **/
public <T> ComponentAdapter<T> getComponentAdapter(final Class<T> componentType, final NameBinding componentNameBinding) {
return getComponentAdapter(componentType, componentNameBinding, null);
}
/** {@inheritDoc} **/
private <T> ComponentAdapter<T> getComponentAdapter(final Class<T> componentType, final NameBinding componentNameBinding, final Class<? extends Annotation> binding) {
// See http://jira.codehaus.org/secure/ViewIssue.jspa?key=PICO-115
ComponentAdapter<?> adapterByKey = getComponentAdapter(componentType);
if (adapterByKey != null) {
return typeComponentAdapter(adapterByKey);
}
List<ComponentAdapter<T>> found = binding == null ? getComponentAdapters(componentType) : getComponentAdapters(componentType, binding);
if (found.size() == 1) {
return found.get(0);
} else if (found.isEmpty()) {
if (parent != null) {
return getParent().getComponentAdapter(componentType, componentNameBinding);
} else {
return null;
}
} else {
if (componentNameBinding != null) {
String parameterName = componentNameBinding.getName();
if (parameterName != null) {
ComponentAdapter<?> ca = getComponentAdapter(parameterName);
if (ca != null && componentType.isAssignableFrom(ca.getComponentImplementation())) {
return typeComponentAdapter(ca);
}
}
}
Class<?>[] foundClasses = new Class[found.size()];
for (int i = 0; i < foundClasses.length; i++) {
foundClasses[i] = found.get(i).getComponentImplementation();
}
throw new AbstractInjector.AmbiguousComponentResolutionException(componentType, foundClasses);
}
}
/** {@inheritDoc} **/
public <T> ComponentAdapter<T> getComponentAdapter(final Class<T> componentType, final Class<? extends Annotation> binding) {
return getComponentAdapter(componentType, null, binding);
}
/** {@inheritDoc} **/
public <T> List<ComponentAdapter<T>> getComponentAdapters(final Class<T> componentType) {
return getComponentAdapters(componentType, null);
}
/** {@inheritDoc} **/
public <T> List<ComponentAdapter<T>> getComponentAdapters(final Class<T> componentType, final Class<? extends Annotation> binding) {
if (componentType == null) {
return Collections.emptyList();
}
List<ComponentAdapter<T>> found = new ArrayList<ComponentAdapter<T>>();
for (ComponentAdapter<?> componentAdapter : getComponentAdapters()) {
Object k = componentAdapter.getComponentKey();
if (componentType.isAssignableFrom(componentAdapter.getComponentImplementation()) &&
(!(k instanceof BindKey) || (k instanceof BindKey && (((BindKey<?>)k).getAnnotation() == null || binding == null ||
((BindKey<?>)k).getAnnotation() == binding)))) {
found.add((ComponentAdapter<T>)typeComponentAdapter(componentAdapter));
}
}
return found;
}
protected MutablePicoContainer addAdapterInternal(ComponentAdapter<?> componentAdapter) {
Object componentKey = componentAdapter.getComponentKey();
if (getComponentKeyToAdapterCache().containsKey(componentKey)) {
throw new PicoCompositionException("Duplicate Keys not allowed. Duplicate for '" + componentKey + "'");
}
getModifiableComponentAdapterList().add(componentAdapter);
getComponentKeyToAdapterCache().put(componentKey, componentAdapter);
return this;
}
/**
* {@inheritDoc}
* This method can be used to override the ComponentAdapter created by the {@link ComponentFactory}
* passed to the constructor of this container.
*/
public MutablePicoContainer addAdapter(final ComponentAdapter<?> componentAdapter) {
return addAdapter(componentAdapter, this.componentProperties);
}
/** {@inheritDoc} **/
public MutablePicoContainer addAdapter(final ComponentAdapter<?> componentAdapter, final Properties properties) {
Properties tmpProperties = (Properties)properties.clone();
if (AbstractBehaviorFactory.removePropertiesIfPresent(tmpProperties, Characteristics.NONE) == false && componentFactory instanceof BehaviorFactory) {
MutablePicoContainer container = addAdapterInternal(((BehaviorFactory)componentFactory).addComponentAdapter(
componentMonitor,
lifecycleStrategy,
tmpProperties,
componentAdapter));
throwIfPropertiesLeft(tmpProperties);
return container;
} else {
return addAdapterInternal(componentAdapter);
}
}
/** {@inheritDoc} **/
public <T> ComponentAdapter<T> removeComponent(final Object componentKey) {
lifecycleState.removingComponent();
ComponentAdapter<T> adapter = (ComponentAdapter<T>) getComponentKeyToAdapterCache().remove(componentKey);
getModifiableComponentAdapterList().remove(adapter);
getOrderedComponentAdapters().remove(adapter);
return adapter;
}
/**
* {@inheritDoc}
* The returned ComponentAdapter will be an {@link org.picocontainer.adapters.InstanceAdapter}.
*/
public MutablePicoContainer addComponent(final Object implOrInstance) {
return addComponent(implOrInstance, this.componentProperties);
}
private MutablePicoContainer addComponent(final Object implOrInstance, final Properties props) {
Class<?> clazz;
if (implOrInstance instanceof String) {
return addComponent(implOrInstance, implOrInstance);
}
if (implOrInstance instanceof Class) {
clazz = (Class<?>)implOrInstance;
} else {
clazz = implOrInstance.getClass();
}
return addComponent(clazz, implOrInstance, props);
}
public MutablePicoContainer addConfig(final String name, final Object val) {
return addAdapterInternal(new InstanceAdapter<Object>(name, val, lifecycleStrategy, componentMonitor));
}
/**
* {@inheritDoc}
* The returned ComponentAdapter will be instantiated by the {@link ComponentFactory}
* passed to the container's constructor.
*/
public MutablePicoContainer addComponent(final Object componentKey,
final Object componentImplementationOrInstance,
final Parameter... parameters) {
return this.addComponent(componentKey, componentImplementationOrInstance, this.componentProperties, parameters);
}
private MutablePicoContainer addComponent(final Object componentKey,
final Object componentImplementationOrInstance,
final Properties properties,
Parameter... parameters) {
if (parameters != null && parameters.length == 0 && parameters != Parameter.ZERO) {
parameters = null; // backwards compatibility! solve this better later - Paul
}
if (componentImplementationOrInstance instanceof Class) {
Properties tmpProperties = (Properties) properties.clone();
ComponentAdapter<?> componentAdapter = componentFactory.createComponentAdapter(componentMonitor,
lifecycleStrategy,
tmpProperties,
componentKey,
(Class<?>)componentImplementationOrInstance,
parameters);
AbstractBehaviorFactory.removePropertiesIfPresent(tmpProperties, Characteristics.USE_NAMES);
throwIfPropertiesLeft(tmpProperties);
return addAdapterInternal(componentAdapter);
} else {
ComponentAdapter<?> componentAdapter =
new InstanceAdapter<Object>(componentKey, componentImplementationOrInstance, lifecycleStrategy, componentMonitor);
return addAdapter(componentAdapter, properties);
}
}
private void throwIfPropertiesLeft(final Properties tmpProperties) {
if(tmpProperties.size() > 0) {
throw new PicoCompositionException("Unprocessed Characteristics:" + tmpProperties +", please refer to http://picocontainer.org/unprocessed-properties-help.html");
}
}
private void addOrderedComponentAdapter(final ComponentAdapter<?> componentAdapter) {
if (!getOrderedComponentAdapters().contains(componentAdapter)) {
getOrderedComponentAdapters().add(componentAdapter);
}
}
public List<Object> getComponents() throws PicoException {
return getComponents(Object.class);
}
public <T> List<T> getComponents(final Class<T> componentType) {
if (componentType == null) {
return Collections.emptyList();
}
Map<ComponentAdapter<T>, T> adapterToInstanceMap = new HashMap<ComponentAdapter<T>, T>();
for (ComponentAdapter<?> componentAdapter : getModifiableComponentAdapterList()) {
if (componentType.isAssignableFrom(componentAdapter.getComponentImplementation())) {
ComponentAdapter<T> typedComponentAdapter = typeComponentAdapter(componentAdapter);
T componentInstance = getLocalInstance(typedComponentAdapter);
adapterToInstanceMap.put(typedComponentAdapter, componentInstance);
}
}
List<T> result = new ArrayList<T>();
for (ComponentAdapter<?> componentAdapter : getOrderedComponentAdapters()) {
final T componentInstance = adapterToInstanceMap.get(componentAdapter);
if (componentInstance != null) {
// may be null in the case of the "implicit" addAdapter
// representing "this".
result.add(componentInstance);
}
}
return result;
}
private <T> T getLocalInstance(final ComponentAdapter<T> typedComponentAdapter) {
T componentInstance = typedComponentAdapter.getComponentInstance(this, ComponentAdapter.NOTHING.class);
// This is to ensure all are added. (Indirect dependencies will be added
// from InstantiatingComponentAdapter).
addOrderedComponentAdapter(typedComponentAdapter);
return componentInstance;
}
@SuppressWarnings({ "unchecked" })
private static <T> ComponentAdapter<T> typeComponentAdapter(final ComponentAdapter<?> componentAdapter) {
return (ComponentAdapter<T>)componentAdapter;
}
public Object getComponent(final Object componentKeyOrType) {
return getComponent(componentKeyOrType, null);
}
public Object getComponent(final Object componentKeyOrType, Type into) {
synchronized (this) {
if (intoThreadLocal == null) {
intoThreadLocal = new IntoThreadLocal();
}
}
intoThreadLocal.set(into);
return getComponent(componentKeyOrType, (Class<? extends Annotation>) null);
}
public Object getComponent(final Object componentKeyOrType, final Class<? extends Annotation> annotation) {
Object retVal;
if (annotation != null) {
final ComponentAdapter<?> componentAdapter = getComponentAdapter((Class<?>)componentKeyOrType, annotation);
retVal = componentAdapter == null ? null : getInstance(componentAdapter, null);
} else if (componentKeyOrType instanceof Class) {
final ComponentAdapter<?> componentAdapter = getComponentAdapter((Class<?>)componentKeyOrType, (NameBinding) null);
retVal = componentAdapter == null ? null : getInstance(componentAdapter, (Class<?>)componentKeyOrType);
} else {
ComponentAdapter<?> componentAdapter = getComponentAdapter(componentKeyOrType);
retVal = componentAdapter == null ? null : getInstance(componentAdapter, null);
}
if (retVal == null) {
retVal = componentMonitor.noComponentFound(this, componentKeyOrType);
}
return retVal;
}
public <T> T getComponent(final Class<T> componentType) {
Object o = getComponent((Object)componentType, null);
return componentType.cast(o);
}
public <T> T getComponent(final Class<T> componentType, final Class<? extends Annotation> binding) {
Object o = getComponent((Object)componentType, binding);
return componentType.cast(o);
}
private Object getInstance(final ComponentAdapter<?> componentAdapter, Class componentKey) {
// check whether this is our adapter
// we need to check this to ensure up-down dependencies cannot be followed
final boolean isLocal = getModifiableComponentAdapterList().contains(componentAdapter);
if (isLocal) {
Object instance;
try {
if (componentAdapter instanceof FactoryInjector) {
instance = ((FactoryInjector) componentAdapter).getComponentInstance(this, intoThreadLocal.get());
} else {
synchronized (this) {
if (intoThreadLocal == null) {
intoThreadLocal = new IntoThreadLocal();
}
}
intoThreadLocal.set(componentAdapter.getComponentImplementation());
instance = componentAdapter.getComponentInstance(this, ComponentAdapter.NOTHING.class);
}
} catch (AbstractInjector.CyclicDependencyException e) {
if (parent != null) {
instance = getParent().getComponent(componentAdapter.getComponentKey());
if (instance != null) {
return instance;
}
}
throw e;
}
addOrderedComponentAdapter(componentAdapter);
return instance;
} else if (parent != null) {
return getParent().getComponent(componentAdapter.getComponentKey());
}
return null;
}
/** {@inheritDoc} **/
public PicoContainer getParent() {
return parent;
}
/** {@inheritDoc} **/
public <T> ComponentAdapter<T> removeComponentByInstance(final T componentInstance) {
for (ComponentAdapter<?> componentAdapter : getModifiableComponentAdapterList()) {
if (getLocalInstance(componentAdapter).equals(componentInstance)) {
return removeComponent(componentAdapter.getComponentKey());
}
}
return null;
}
/**
* Start the components of this PicoContainer and all its logical child containers.
* The starting of the child container is only attempted if the parent
* container start successfully. The child container for which start is attempted
* is tracked so that upon stop, only those need to be stopped.
* The lifecycle operation is delegated to the component adapter,
* if it is an instance of {@link Behavior lifecycle manager}.
* The actual {@link LifecycleStrategy lifecycle strategy} supported
* depends on the concrete implementation of the adapter.
*
* @see Behavior
* @see LifecycleStrategy
* @see #makeChildContainer()
* @see #addChildContainer(PicoContainer)
* @see #removeChildContainer(PicoContainer)
*/
public void start() {
lifecycleState.starting();
startAdapters();
childrenStarted.clear();
for (PicoContainer child : children) {
childrenStarted.add(new WeakReference<PicoContainer>(child));
if (child instanceof Startable) {
((Startable)child).start();
}
}
}
/**
* Stop the components of this PicoContainer and all its logical child containers.
* The stopping of the child containers is only attempted for those that have been
* started, possibly not successfully.
* The lifecycle operation is delegated to the component adapter,
* if it is an instance of {@link Behavior lifecycle manager}.
* The actual {@link LifecycleStrategy lifecycle strategy} supported
* depends on the concrete implementation of the adapter.
*
* @see Behavior
* @see LifecycleStrategy
* @see #makeChildContainer()
* @see #addChildContainer(PicoContainer)
* @see #removeChildContainer(PicoContainer)
*/
public void stop() {
lifecycleState.stopping();
for (PicoContainer child : children) {
if (childStarted(child)) {
if (child instanceof Startable) {
((Startable)child).stop();
}
}
}
stopAdapters();
lifecycleState.stopped();
}
/**
* Checks the status of the child container to see if it's been started
* to prevent IllegalStateException upon stop
*
* @param child the child PicoContainer
*
* @return A boolean, <code>true</code> if the container is started
*/
private boolean childStarted(final PicoContainer child) {
for (WeakReference<PicoContainer> eachChild : childrenStarted) {
PicoContainer ref = eachChild.get();
if (ref == null) {
continue;
}
if (child.equals(ref)) {
return true;
}
}
return false;
}
/**
* Dispose the components of this PicoContainer and all its logical child containers.
* The lifecycle operation is delegated to the component adapter,
* if it is an instance of {@link Behavior lifecycle manager}.
* The actual {@link LifecycleStrategy lifecycle strategy} supported
* depends on the concrete implementation of the adapter.
*
* @see Behavior
* @see LifecycleStrategy
* @see #makeChildContainer()
* @see #addChildContainer(PicoContainer)
* @see #removeChildContainer(PicoContainer)
*/
public void dispose() {
if (lifecycleState.isStarted()) {
stop();
}
lifecycleState.disposing();
for (PicoContainer child : children) {
if (child instanceof MutablePicoContainer) {
((Disposable)child).dispose();
}
}
disposeAdapters();
lifecycleState.disposed();
}
public void setLifecycleState(LifecycleState lifecycleState) {
this.lifecycleState = lifecycleState;
}
public MutablePicoContainer makeChildContainer() {
DefaultPicoContainer pc = new DefaultPicoContainer(componentFactory, lifecycleStrategy, this, componentMonitor);
addChildContainer(pc);
return pc;
}
/**
* Checks for identical references in the child container. It doesn't
* traverse an entire hierarchy, namely it simply checks for child containers
* that are equal to the current container.
* @param child
*/
private void checkCircularChildDependencies(PicoContainer child) {
final String MESSAGE = "Cannot have circular dependency between parent "
+ this + " and child: " + child;
if (child == this) {
throw new IllegalArgumentException(MESSAGE);
}
//Todo: Circular Import Dependency on AbstractDelegatingPicoContainer
if (child instanceof AbstractDelegatingPicoContainer) {
AbstractDelegatingPicoContainer delegateChild = (AbstractDelegatingPicoContainer) child;
while(delegateChild != null) {
PicoContainer delegateInstance = delegateChild.getDelegate();
if (this == delegateInstance) {
throw new IllegalArgumentException(MESSAGE);
}
if (delegateInstance instanceof AbstractDelegatingPicoContainer) {
delegateChild = (AbstractDelegatingPicoContainer) delegateInstance;
} else {
delegateChild = null;
}
}
}
}
public MutablePicoContainer addChildContainer(final PicoContainer child) {
checkCircularChildDependencies(child);
if (children.add(child)) {
// @todo Should only be added if child container has also be started
if (lifecycleState.isStarted()) {
childrenStarted.add(new WeakReference<PicoContainer>(child));
}
}
return this;
}
public boolean removeChildContainer(final PicoContainer child) {
final boolean result = children.remove(child);
WeakReference<PicoContainer> foundRef = null;
for (WeakReference<PicoContainer> eachChild : childrenStarted) {
PicoContainer ref = eachChild.get();
if (ref.equals(child)) {
foundRef = eachChild;
break;
}
}
if (foundRef != null) {
childrenStarted.remove(foundRef);
}
return result;
}
public MutablePicoContainer change(final Properties... properties) {
for (Properties c : properties) {
Enumeration<String> e = (Enumeration<String>) c.propertyNames();
while (e.hasMoreElements()) {
String s = e.nextElement();
componentProperties.setProperty(s,c.getProperty(s));
}
}
return this;
}
public MutablePicoContainer as(final Properties... properties) {
return new AsPropertiesPicoContainer(properties);
}
public void accept(final PicoVisitor visitor) {
//Pico 3 todo, change accept signatures to allow abort at any point in the traversal.
boolean shouldContinue = visitor.visitContainer(this);
if (!shouldContinue) {
return;
}
componentFactory.accept(visitor); // will cascade through behaviors
final List<ComponentAdapter<?>> componentAdapters = new ArrayList<ComponentAdapter<?>>(getComponentAdapters());
for (ComponentAdapter<?> componentAdapter : componentAdapters) {
componentAdapter.accept(visitor);
}
final List<PicoContainer> allChildren = new ArrayList<PicoContainer>(children);
for (PicoContainer child : allChildren) {
child.accept(visitor);
}
}
/**
* Changes monitor in the ComponentFactory, the component adapters
* and the child containers, if these support a ComponentMonitorStrategy.
* {@inheritDoc}
*/
public void changeMonitor(final ComponentMonitor monitor) {
this.componentMonitor = monitor;
if (lifecycleStrategy instanceof ComponentMonitorStrategy) {
((ComponentMonitorStrategy)lifecycleStrategy).changeMonitor(monitor);
}
for (ComponentAdapter<?> adapter : getModifiableComponentAdapterList()) {
if (adapter instanceof ComponentMonitorStrategy) {
((ComponentMonitorStrategy)adapter).changeMonitor(monitor);
}
}
for (PicoContainer child : children) {
if (child instanceof ComponentMonitorStrategy) {
((ComponentMonitorStrategy)child).changeMonitor(monitor);
}
}
}
/**
* Returns the first current monitor found in the ComponentFactory, the component adapters
* and the child containers, if these support a ComponentMonitorStrategy.
* {@inheritDoc}
*
* @throws PicoCompositionException if no component monitor is found in container or its children
*/
public ComponentMonitor currentMonitor() {
return componentMonitor;
}
/**
* {@inheritDoc}
* Loops over all component adapters and invokes
* start(PicoContainer) method on the ones which are LifecycleManagers
*/
private void startAdapters() {
Collection<ComponentAdapter<?>> adapters = getComponentAdapters();
for (ComponentAdapter<?> adapter : adapters) {
if (adapter instanceof Behavior) {
Behavior<?> behaviorAdapter = (Behavior<?>)adapter;
if (behaviorAdapter.componentHasLifecycle()) {
// create an instance, it will be added to the ordered CA list
adapter.getComponentInstance(DefaultPicoContainer.this, ComponentAdapter.NOTHING.class);
addOrderedComponentAdapter(adapter);
}
}
}
adapters = getOrderedComponentAdapters();
// clear list of started CAs
startedComponentAdapters.clear();
// clone the adapters
List<ComponentAdapter<?>> adaptersClone = new ArrayList<ComponentAdapter<?>>(adapters);
for (final ComponentAdapter<?> adapter : adaptersClone) {
if (adapter instanceof Behavior) {
Behavior<?> manager = (Behavior<?>)adapter;
manager.start(DefaultPicoContainer.this);
startedComponentAdapters.add(new WeakReference<ComponentAdapter<?>>(adapter));
}
}
}
/**
* {@inheritDoc}
* Loops over started component adapters (in inverse order) and invokes
* stop(PicoContainer) method on the ones which are LifecycleManagers
*/
private void stopAdapters() {
for (int i = startedComponentAdapters.size() - 1; 0 <= i; i--) {
ComponentAdapter<?> adapter = startedComponentAdapters.get(i).get();
if (adapter == null) {
//Weak reference -- may be null
continue;
}
if (adapter instanceof Behavior) {
Behavior<?> manager = (Behavior<?>)adapter;
manager.stop(DefaultPicoContainer.this);
}
}
}
/**
* {@inheritDoc}
* Loops over all component adapters (in inverse order) and invokes
* dispose(PicoContainer) method on the ones which are LifecycleManagers
*/
private void disposeAdapters() {
for (int i = getOrderedComponentAdapters().size() - 1; 0 <= i; i--) {
ComponentAdapter<?> adapter = getOrderedComponentAdapters().get(i);
if (adapter instanceof Behavior) {
Behavior<?>manager = (Behavior<?>)adapter;
manager.dispose(DefaultPicoContainer.this);
}
}
}
/**
* @return the orderedComponentAdapters
*/
protected List<ComponentAdapter<?>> getOrderedComponentAdapters() {
return orderedComponentAdapters;
}
/**
* @return the componentKeyToAdapterCache
*/
protected Map<Object, ComponentAdapter<?>> getComponentKeyToAdapterCache() {
return componentKeyToAdapterCache;
}
/**
* @return the componentAdapters
*/
protected List<ComponentAdapter<?>> getModifiableComponentAdapterList() {
return componentAdapters;
}
public void setName(String name) {
this.name = name;
}
public String toString() {
return String.format("%s:%d<%s", (name != null ? name : super.toString()), this.componentAdapters.size(), (parent != null ? parent.toString() : "|"));
}
private class AsPropertiesPicoContainer extends AbstractDelegatingMutablePicoContainer {
private final Properties properties;
public AsPropertiesPicoContainer(final Properties... props) {
super(DefaultPicoContainer.this);
properties = (Properties) componentProperties.clone();
for (Properties c : props) {
Enumeration<?> e = c.propertyNames();
while (e.hasMoreElements()) {
String s = (String)e.nextElement();
properties.setProperty(s,c.getProperty(s));
}
}
}
@Override
public MutablePicoContainer as(Properties... properties) {
throw new PicoCompositionException("Syntax 'as(FOO).as(BAR)' not allowed, do 'as(FOO, BAR)' instead");
}
@Override
public MutablePicoContainer makeChildContainer() {
return getDelegate().makeChildContainer();
}
@Override
public MutablePicoContainer addComponent(final Object componentKey,
final Object componentImplementationOrInstance,
final Parameter... parameters) throws PicoCompositionException {
return DefaultPicoContainer.this.addComponent(componentKey,
componentImplementationOrInstance,
properties,
parameters);
}
@Override
public MutablePicoContainer addComponent(final Object implOrInstance) throws PicoCompositionException {
return DefaultPicoContainer.this.addComponent(implOrInstance, properties);
}
@Override
public MutablePicoContainer addAdapter(final ComponentAdapter<?> componentAdapter) throws PicoCompositionException {
return DefaultPicoContainer.this.addAdapter(componentAdapter, properties);
}
}
private static class IntoThreadLocal extends ThreadLocal<Type> implements Serializable {
protected Type initialValue() {
return ComponentAdapter.NOTHING.class;
}
}
}
The table below shows all metrics for DefaultPicoContainer.java.
| Metric | Value | Description | |
|---|---|---|---|
| BLOCKS | 164.00 | Number of blocks | |
| BLOCK_COMMENT | 0.00 | Number of block comment lines | |
| COMMENTS | 267.00 | Comment lines | |
| COMMENT_DENSITY | 0.58 | Comment density | |
| COMPARISONS | 68.00 | Number of comparison operators | |
| CYCLOMATIC | 153.00 | Cyclomatic complexity | |
| DECL_COMMENTS | 47.00 | Comments in declarations | |
| DOC_COMMENT | 253.00 | Number of javadoc comment lines | |
| ELOC | 458.00 | Effective lines of code | |
| EXEC_COMMENTS | 11.00 | Comments in executable code | |
| EXITS | 133.00 | Procedure exits | |
| FUNCTIONS | 69.00 | Number of function declarations | |
| HALSTEAD_DIFFICULTY | 84.50 | Halstead difficulty | |
| HALSTEAD_EFFORT | 0.00 | Halstead effort | |
| INTERFACE_COMPLEXITY | 175.00 | Interface complexity | |
| JAVA0001 | 0.00 | JAVA0001 Package name does not contain only lower case letters | |
| JAVA0002 | 0.00 | JAVA0002 Package name does not begin with a top level domain name or country code | |
| JAVA0003 | 0.00 | JAVA0003 Minimize use of on-demand (.*) imports | |
| JAVA0004 | 0.00 | JAVA0004 Unnecessary import from java.lang | |
| JAVA0005 | 0.00 | JAVA0005 Imports not in specified order | |
| JAVA0006 | 0.00 | JAVA0006 Empty finally block | |
| JAVA0007 | 0.00 | JAVA0007 Should not declare public field | |
| JAVA0008 | 0.00 | JAVA0008 Empty catch block | |
| JAVA0009 | 0.00 | JAVA0009 Protected member in final class | |
| JAVA0010 | 0.00 | JAVA0010 Non-instantiable class does not contain a non-private static member | |
| JAVA0011 | 0.00 | JAVA0011 Abstract class does not contain an abstract method | |
| JAVA0012 | 0.00 | JAVA0012 Non-constructor method with same name as declaring class | |
| JAVA0013 | 0.00 | JAVA0013 Non-blank final field is not static | |
| JAVA0014 | 0.00 | JAVA0014 Class with only static members has non-private constructor | |
| JAVA0015 | 0.00 | JAVA0015 Package class contains public nested type | |
| JAVA0016 | 0.00 | JAVA0016 Abstract class contains public constructor | |
| JAVA0017 | 0.00 | JAVA0017 Class name does not have required form | |
| JAVA0018 | 0.00 | JAVA0018 Method name does not have required form | |
| JAVA0019 | 0.00 | JAVA0019 Interface name does not have required form | |
| JAVA0020 | 0.00 | JAVA0020 Field name does not have required form | |
| JAVA0021 | 0.00 | JAVA0021 Interface method name does not have required form | |
| JAVA0022 | 0.00 | JAVA0022 Static final field name does not have required form | |
| JAVA0023 | 0.00 | JAVA0023 Empty finalize method | |
| JAVA0024 | 0.00 | JAVA0024 Empty class | |
| JAVA0025 | 0.00 | JAVA0025 Method override is empty | |
| JAVA0026 | 0.00 | JAVA0026 Finalize method with parameters | |
| JAVA0029 | 0.00 | JAVA0029 Private method not used | |
| JAVA0030 | 0.00 | JAVA0030 Private field not used | |
| JAVA0031 | 0.00 | JAVA0031 Case statement not properly closed | |
| JAVA0032 | 0.00 | JAVA0032 Switch statement missing default | |
| JAVA0033 | 0.00 | JAVA0033 default: not last case in switch statement | |
| JAVA0034 | 0.00 | JAVA0034 Missing braces in if statement | |
| JAVA0035 | 0.00 | JAVA0035 Missing braces in for statement | |
| JAVA0036 | 0.00 | JAVA0036 Missing braces in while statement | |
| JAVA0038 | 0.00 | JAVA0038 Non-case label in switch statement | |
| JAVA0039 | 0.00 | JAVA0039 Break statement with label | |
| JAVA0040 | 0.00 | JAVA0040 Switch statement contains N cases (maximum: M) | |
| JAVA0041 | 0.00 | JAVA0041 Nested synchronized block | |
| JAVA0042 | 0.00 | JAVA0042 Empty synchronized statement | |
| JAVA0043 | 0.00 | JAVA0043 Inner class does not use outer class | |
| JAVA0044 | 1.00 | JAVA0044 Serializable class with no instance variables | |
| JAVA0045 | 0.00 | JAVA0045 Serializable class with only transient fields | |
| JAVA0046 | 0.00 | JAVA0046 Name of class not derived from Exception ends with 'Exception' | |
| JAVA0047 | 0.00 | JAVA0047 Serializable class derives from invalid base class | |
| JAVA0048 | 0.00 | JAVA0048 Name of class derived from Exception does not end with 'Exception' | |
| JAVA0049 | 1.00 | JAVA0049 Nested block at depth N (maximum: M) | |
| JAVA0050 | 0.00 | JAVA0050 Class derives from java.lang.Error | |
| JAVA0051 | 0.00 | JAVA0051 Class derives from java.lang.RuntimeException | |
| JAVA0052 | 0.00 | JAVA0052 Class derives from java.lang.Throwable | |
| JAVA0053 | 0.00 | JAVA0053 Unused label | |
| JAVA0054 | 0.00 | JAVA0054 Inheritance depth N exceeds maximum M | |
| JAVA0055 | 0.00 | JAVA0055 Class should be interface | |
| JAVA0056 | 0.00 | JAVA0056 Unnecessary abstract modifier for interface or annotation | |
| JAVA0057 | 0.00 | JAVA0057 Unnecessary default constructor | |
| JAVA0058 | 0.00 | JAVA0058 Constructor calls super() | |
| JAVA0059 | 0.00 | JAVA0059 Method override only calls super() | |
| JAVA0061 | 0.00 | JAVA0061 Inaccessible member in anonymous class | |
| JAVA0062 | 0.00 | JAVA0062 Public class missing public member or protected constructor | |
| JAVA0063 | 0.00 | JAVA0063 Identifier name should not contain '$' | |
| JAVA0064 | 0.00 | JAVA0064 N variations of identifier name (maximum: M) | |
| JAVA0065 | 0.00 | JAVA0065 Unnecessary final modifier for method in final class | |
| JAVA0066 | 0.00 | JAVA0066 Unnecessary modifier for interface nested type | |
| JAVA0067 | 0.00 | JAVA0067 Array descriptor on identifier name | |
| JAVA0068 | 0.00 | JAVA0068 Modifiers not declared in recommended order | |
| JAVA0071 | 0.00 | JAVA0071 Strings compared with == | |
| JAVA0073 | 0.00 | JAVA0073 Integer division in floating-point context | |
| JAVA0074 | 0.00 | JAVA0074 Use of Object.notify() | |
| JAVA0075 | 2.00 | JAVA0075 Method parameter hides field | |
| JAVA0076 | 0.00 | JAVA0076 Use of magic number | |
| JAVA0077 | 0.00 | JAVA0077 Private field not used in declaring class | |
| JAVA0078 | 0.00 | JAVA0078 Floating point values compared with == | |
| JAVA0079 | 0.00 | JAVA0079 Use of instance to reference static member | |
| JAVA0080 | 0.00 | JAVA0080 Import declaration not used | |
| JAVA0081 | 1.00 | JAVA0081 Boolean literal in comparison | |
| JAVA0082 | 2.00 | JAVA0082 Unnecessary widening cast | |
| JAVA0083 | 0.00 | JAVA0083 Unnecessary instanceof test | |
| JAVA0084 | 0.00 | JAVA0084 Should use compound assignment operator | |
| JAVA0085 | 0.00 | JAVA0085 Use of sun.* class | |
| JAVA0087 | 0.00 | JAVA0087 Use of Thread.sleep() | |
| JAVA0089 | 0.00 | JAVA0089 Use of restricted package | |
| JAVA0092 | 0.00 | JAVA0092 Use of restricted type | |
| JAVA0093 | 0.00 | JAVA0093 Redundant assignment | |
| JAVA0094 | 0.00 | JAVA0094 Field hides a superclass field | |
| JAVA0095 | 0.00 | JAVA0095 Uninitialized private field | |
| JAVA0096 | 0.00 | JAVA0096 Field in nested class hides outer field | |
| JAVA0098 | 0.00 | JAVA0098 Minimize use of implicit field initializers | |
| JAVA0100 | 0.00 | JAVA0100 Class contains N non-final fields (maximum: M) | |
| JAVA0101 | 0.00 | JAVA0101 Unnecessary modifier for field in interface | |
| JAVA0102 | 0.00 | JAVA0102 Last statement in finalize() not super.finalize() | |
| JAVA0103 | 0.00 | JAVA0103 Explicit call to finalize() | |
| JAVA0104 | 0.00 | JAVA0104 finalize() only calls super.finalize() | |
| JAVA0105 | 0.00 | JAVA0105 Duplicate import declaration | |
| JAVA0106 | 0.00 | JAVA0106 Unnecessary import from current package | |
| JAVA0108 | 5.00 | JAVA0108 Incorrect javadoc: no @param tag for 'parameter' | |
| JAVA0109 | 0.00 | JAVA0109 Incorrect javadoc: no parameter 'parameter' | |
| JAVA0110 | 15.00 | JAVA0110 Incorrect javadoc: no @return tag | |
| JAVA0111 | 0.00 | JAVA0111 Incorrect javadoc: @return tag for void method | |
| JAVA0112 | 0.00 | JAVA0112 Incorrect javadoc: no exception 'exception' in throws | |
| JAVA0113 | 0.00 | JAVA0113 Incorrect javadoc: no @author tag | |
| JAVA0114 | 1.00 | JAVA0114 Incorrect javadoc: no @version tag | |
| JAVA0115 | 0.00 | JAVA0115 Incorrect javadoc: no @throws or @exception tag for 'exception' | |
| JAVA0116 | 0.00 | JAVA0116 Missing javadoc: field 'field' | |
| JAVA0117 | 6.00 | JAVA0117 Missing javadoc: method 'method' | |
| JAVA0118 | 0.00 | JAVA0118 Missing javadoc: type 'type' | |
| JAVA0119 | 0.00 | JAVA0119 Control variable changed within body of for loop | |
| JAVA0123 | 0.00 | JAVA0123 Use all three components of for loop | |
| JAVA0125 | 0.00 | JAVA0125 Continue statement with label | |
| JAVA0126 | 4.00 | JAVA0126 Method declares unchecked exception in throws | |
| JAVA0128 | 1.00 | JAVA0128 Public constructor in non-public class | |
| JAVA0130 | 1.00 | JAVA0130 Non-static method does not use instance fields | |
| JAVA0131 | 0.00 | JAVA0131 Compatible method does not override base | |
| JAVA0132 | 3.00 | JAVA0132 Method overload with compatible signature | |
| JAVA0133 | 0.00 | JAVA0133 Non-synchronized method overrides synchronized method | |
| JAVA0135 | 0.00 | JAVA0135 Only one of Object.equals and Object.hashCode defined: missing 'method' | |
| JAVA0136 | 1.00 | JAVA0136 N methods defined in class (maximum: M) | |
| JAVA0137 | 0.00 | JAVA0137 Non-abstract class missing constructor | |
| JAVA0138 | 0.00 | JAVA0138 N parameters defined for method (maximum: M) | |
| JAVA0139 | 0.00 | JAVA0139 Definition of main other than public static void main(java.lang.String[]) | |
| JAVA0141 | 0.00 | JAVA0141 Unnecessary modifier for method in interface | |
| JAVA0143 | 0.00 | JAVA0143 Synchronized method | |
| JAVA0144 | 9.00 | JAVA0144 Line exceeds maximum M characters | |
| JAVA0145 | 145.00 | JAVA0145 Tab character used in source file | |
| JAVA0150 | 0.00 | JAVA0150 java.lang.Error (or subclass) thrown | |
| JAVA0153 | 0.00 | JAVA0153 Inefficient conversion of integer to string | |
| JAVA0159 | 0.00 | JAVA0159 Inefficient conversion of string to integer | |
| JAVA0160 | 0.00 | JAVA0160 Method does not throw specified exception | |
| JAVA0161 | 0.00 | JAVA0161 Conditional wait() not in loop | |
| JAVA0163 | 0.00 | JAVA0163 Empty statement | |
| JAVA0165 | 0.00 | JAVA0165 Conflicting return statement in finally block | |
| JAVA0166 | 0.00 | JAVA0166 Generic exception caught | |
| JAVA0167 | 0.00 | JAVA0167 ThreadDeath not rethrown | |
| JAVA0169 | 0.00 | JAVA0169 Unnecessary catch block: exception 'exception' | |
| JAVA0170 | 0.00 | JAVA0170 Caught exception not derived from java.lang.Exception | |
| JAVA0171 | 0.00 | JAVA0171 Unused local variable | |
| JAVA0173 | 1.00 | JAVA0173 Unused method parameter | |
| JAVA0174 | 0.00 | JAVA0174 Assigned local variable never used | |
| JAVA0175 | 0.00 | JAVA0175 Successive assignment to variable | |
| JAVA0176 | 0.00 | JAVA0176 Local variable name does not have required form | |
| JAVA0177 | 3.00 | JAVA0177 Variable declaration missing initializer | |
| JAVA0179 | 1.00 | JAVA0179 Local variable hides visible field | |
| JAVA0233 | 0.00 | JAVA0233 Definition of serialVersionUID other than 'private static final long serialVersionUID' | |
| JAVA0234 | 3.00 | JAVA0234 Class is Serializable but does not define serialVersionUID | |
| JAVA0235 | 0.00 | JAVA0235 Class defines serialVersionUID but does not implement Serializable | |
| JAVA0236 | 0.00 | JAVA0236 Attempt to clone an object which does not implement Cloneable | |
| JAVA0237 | 0.00 | JAVA0237 Class implements Cloneable but does not have public clone method | |
| JAVA0238 | 0.00 | JAVA0238 Clone method does not call super.clone() | |
| JAVA0239 | 0.00 | JAVA0239 Class declares 'readObject' or 'writeObject' but does not implement Serializable | |
| JAVA0240 | 0.00 | JAVA0240 Serializable class which declares readObject or writeObject but not both | |
| JAVA0241 | 0.00 | JAVA0241 'readObject' or 'writeObject' should be declared private in Serializable class | |
| JAVA0242 | 0.00 | JAVA0242 Transient field in non-Serializable class | |
| JAVA0243 | 0.00 | JAVA0243 'readResolve' or 'writeReplace' should be declared private or protected | |
| JAVA0244 | 0.00 | JAVA0244 Field or method name in subclass differs only by case from inherited field or method | |
| JAVA0245 | 0.00 | JAVA0245 JUnit TestCase with non-trivial constructor | |
| JAVA0246 | 0.00 | JAVA0246 JUnit assertXXX statement missing message parameter | |
| JAVA0247 | 0.00 | JAVA0247 JUnit 'setUp()' and 'tearDown()' should call super method | |
| JAVA0248 | 0.00 | JAVA0248 JUnit method 'setUp' or 'tearDown' with incorrect signature | |
| JAVA0249 | 0.00 | JAVA0249 JUnit TestCase 'suite()' should be declared static | |
| JAVA0250 | 0.00 | JAVA0250 JUnit TestCase declares testXXX method with incorrect signature | |
| JAVA0251 | 0.00 | JAVA0251 Use '%n' for line breaks in printf/format for platform independence | |
| JAVA0252 | 0.00 | JAVA0252 'enum' is a Java 1.5 reserved word | |
| JAVA0253 | 0.00 | JAVA0253 Not all enum constants consumed in switch statement | |
| JAVA0254 | 0.00 | JAVA0254 Use enhanced for loop construct instead of Iterator | |
| JAVA0255 | 0.00 | JAVA0255 Result of method invocation not used | |
| JAVA0256 | 0.00 | JAVA0256 Assignment of external collection/array to field | |
| JAVA0257 | 0.00 | JAVA0257 Use of 'Constant Interface' anti-pattern | |
| JAVA0258 | 0.00 | JAVA0258 Implement Iterable for foreach compatibility | |
| JAVA0259 | 2.00 | JAVA0259 Return of collection/array field | |
| JAVA0260 | 0.00 | JAVA0260 Use 'enum' instead of Enumerated Type pattern | |
| JAVA0261 | 0.00 | JAVA0261 Use specialized Enum collection types | |
| JAVA0262 | 0.00 | JAVA0262 Use of char in integer context | |
| JAVA0263 | 0.00 | JAVA0263 Long literal ends with 'l' instead of 'L' | |
| JAVA0264 | 0.00 | JAVA0264 Integer math in long context - check for overflow | |
| JAVA0265 | 0.00 | JAVA0265 Use of Throwable.printStackTrace() | |
| JAVA0266 | 0.00 | JAVA0266 Use of System.out | |
| JAVA0267 | 0.00 | JAVA0267 Use of System.err | |
| JAVA0269 | 0.00 | JAVA0269 Contents of StringBuffer never used | |
| JAVA0270 | 0.00 | JAVA0270 Use Java 5.0 enhanced for loop construct to iterate over all elements in an array | |
| JAVA0271 | 0.00 | JAVA0271 Minimize use of on-demand (.*) static imports | |
| JAVA0272 | 0.00 | JAVA0272 Thread.run() called | |
| JAVA0273 | 0.00 | JAVA0273 Non-final derivative of Thread calls start() in constructor | |
| JAVA0274 | 0.00 | JAVA0274 Serializable class has a synchronized readObject() | |
| JAVA0275 | 0.00 | JAVA0275 Serializable class has a synchronized writeObject() and no other synchronized methods | |
| JAVA0276 | 0.00 | JAVA0276 Unnecessary use of String constructor | |
| JAVA0277 | 0.00 | JAVA0277 Iterator.next() implementation does not throw NoSuchElementException | |
| JAVA0278 | 0.00 | JAVA0278 Unnecessary use of Boolean constructor | |
| JAVA0279 | 0.00 | JAVA0279 Serialization method readObject or readObjectNoData calls an overridable method | |
| JAVA0280 | 0.00 | JAVA0280 IllegalMonitorStateException caught | |
| JAVA0281 | 0.00 | JAVA0281 Iterator.next() not called in loop | |
| JAVA0282 | 0.00 | JAVA0282 Call to Iterator.next() in loop which does not test Iterator.hasNext() | |
| JAVA0283 | 0.00 | JAVA0283 Control variable not updated in loop body | |
| JAVA0284 | 0.00 | JAVA0284 Explicit garbage collection | |
| JAVA0285 | 0.00 | JAVA0285 Dereference of potentially null variable | |
| JAVA0286 | 0.00 | JAVA0286 Dereference of null variable | |
| JAVA0287 | 0.00 | JAVA0287 Unnecessary null check | |
| JAVA0288 | 0.00 | JAVA0288 Inconsistent null check | |
| LINES | 1015.00 | Number of lines in the source file | |
| LINE_COMMENT | 14.00 | Number of line comments | |
| LOC | 613.00 | Lines of code | |
| LOGICAL_LINES | 263.00 | Number of statements | |
| LOOPS | 6.00 | Number of loops | |
| NEST_DEPTH | 6.00 | Maximum nesting depth | |
| OPERANDS | 1413.00 | Number of operands | |
| OPERATORS | 3022.00 | Number of operators | |
| PARAMS | 80.00 | Number of formal parameter declarations | |
| PROGRAM_LENGTH | 4435.00 | Halstead program length | |
| PROGRAM_VOCAB | 571.00 | Halstead program vocabulary | |
| PROGRAM_VOLUME | 0.00 | Halstead program volume | |
| RETURNS | 95.00 | Number of return points from functions | |
| SIZE | 40689.00 | Size of the file in bytes | |
| UNIQUE_OPERANDS | 510.00 | Number of unique operands | |
| UNIQUE_OPERATORS | 61.00 | Number of unique operators | |
| WHITESPACE | 135.00 | Number of whitespace lines | |