ComponentPageElementImpl.java
| Index Score | ||
|---|---|---|
 |
 |
org.apache.tapestry5.internal.structure |
 |
 |
Apache Tapestry 5 |
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 | |
|---|---|---|
| JAVA0034 | JAVA0034 Missing braces in if statement |  |
| LINE_COMMENT | Number of line comments | |
| EXEC_COMMENTS | Comments in executable code | |
| FUNCTIONS | Number of function declarations | |
| INTERFACE_COMPLEXITY | Interface complexity | |
| PARAMS | Number of formal parameter declarations | |
| SIZE | Size of the file in bytes | |
| RETURNS | Number of return points from functions | |
| EXITS | Procedure exits | |
| CYCLOMATIC | Cyclomatic complexity | |
| WHITESPACE | Number of whitespace lines | |
| LOC | Lines of code | |
| LINES | Number of lines in the source file | |
| UNIQUE_OPERANDS | Number of unique operands | |
| PROGRAM_VOCAB | Halstead program vocabulary | |
| LOGICAL_LINES | Number of statements | |
| PROGRAM_LENGTH | Halstead program length | |
| OPERATORS | Number of operators | |
| OPERANDS | Number of operands | |
| ELOC | Effective lines of code | |
| BLOCKS | Number of blocks | |
| JAVA0077 | JAVA0077 Private field not used in declaring class | |
| COMPARISONS | Number of comparison operators | |
| JAVA0075 | JAVA0075 Method parameter hides field | |
| DECL_COMMENTS | Comments in declarations | |
| JAVA0108 | JAVA0108 Incorrect javadoc: no @param tag for 'parameter' | |
| UNIQUE_OPERATORS | Number of unique operators | |
| JAVA0036 | JAVA0036 Missing braces in while statement | |
| JAVA0166 | JAVA0166 Generic exception caught | |
| PROGRAM_VOLUME | Halstead program volume | |
| JAVA0136 | JAVA0136 N methods defined in class (maximum: M) | |
| JAVA0035 | JAVA0035 Missing braces in for statement | |
| JAVA0126 | JAVA0126 Method declares unchecked exception in throws | |
| JAVA0179 | JAVA0179 Local variable hides visible field | |
| JAVA0117 | JAVA0117 Missing javadoc: method 'method' | |
| JAVA0254 | JAVA0254 Use enhanced for loop construct instead of Iterator | |
| JAVA0130 | JAVA0130 Non-static method does not use instance fields | |
| JAVA0145 | JAVA0145 Tab character used in source file | |
// Copyright 2006, 2007, 2008 The Apache Software Foundation
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package org.apache.tapestry5.internal.structure;
import org.apache.tapestry5.*;
import org.apache.tapestry5.dom.Element;
import org.apache.tapestry5.internal.InternalComponentResources;
import org.apache.tapestry5.internal.TapestryInternalUtils;
import org.apache.tapestry5.internal.services.ComponentEventImpl;
import org.apache.tapestry5.internal.services.EventImpl;
import org.apache.tapestry5.internal.services.Instantiator;
import org.apache.tapestry5.internal.util.NotificationEventCallback;
import org.apache.tapestry5.ioc.BaseLocatable;
import org.apache.tapestry5.ioc.Location;
import org.apache.tapestry5.ioc.internal.util.CollectionFactory;
import org.apache.tapestry5.ioc.internal.util.Defense;
import static org.apache.tapestry5.ioc.internal.util.Defense.notBlank;
import org.apache.tapestry5.ioc.internal.util.InternalUtils;
import org.apache.tapestry5.ioc.internal.util.TapestryException;
import org.apache.tapestry5.model.ComponentModel;
import org.apache.tapestry5.model.ParameterModel;
import org.apache.tapestry5.runtime.*;
import org.slf4j.Logger;
import java.util.*;
/**
* Implements {@link org.apache.tapestry5.internal.structure.PageElement} and represents a component within an overall
* page. Much of a component page element's behavior is delegated to user code, via a {@link
* org.apache.tapestry5.runtime.Component} instance.
* <p/>
* Once instantiated, a ComponentPageElement should be registered as a {@linkplain
* org.apache.tapestry5.internal.structure.Page#addLifecycleListener(org.apache.tapestry5.runtime.PageLifecycleListener)
* lifecycle listener}. This could be done inside the constructors, but that tends to complicate unit tests, so its done
* by {@link org.apache.tapestry5.internal.services.PageElementFactoryImpl}.
* <p/>
*/
public class ComponentPageElementImpl extends BaseLocatable implements ComponentPageElement, PageLifecycleListener
{
/**
* @see #render(org.apache.tapestry5.MarkupWriter, org.apache.tapestry5.runtime.RenderQueue)
*/
private static final RenderCommand POP_COMPONENT_ID = new RenderCommand()
{
public void render(MarkupWriter writer, RenderQueue queue)
{
queue.endComponent();
}
};
private static final ComponentCallback CONTAINING_PAGE_DID_ATTACH = new ComponentCallback()
{
public void run(Component component)
{
component.containingPageDidAttach();
}
};
private static final ComponentCallback CONTAINING_PAGE_DID_DETACH = new ComponentCallback()
{
public void run(Component component)
{
component.containingPageDidDetach();
}
};
private static final ComponentCallback CONTAINING_PAGE_DID_LOAD = new ComponentCallback()
{
public void run(Component component)
{
component.containingPageDidLoad();
}
};
private static final ComponentCallback POST_RENDER_CLEANUP = new ComponentCallback()
{
public void run(Component component)
{
component.postRenderCleanup();
}
};
// For the moment, every component will have a template, even if it consists of
// just a page element to queue up a BeforeRenderBody phase.
private static void pushElements(RenderQueue queue, List<PageElement> list)
{
int count = size(list);
for (int i = count - 1; i >= 0; i--)
queue.push(list.get(i));
}
private static int size(List<?> list)
{
return list == null ? 0 : list.size();
}
private static class RenderPhaseEventHandler implements ComponentEventCallback
{
private boolean result = true;
private List<RenderCommand> commands;
boolean getResult()
{
return result;
}
public boolean handleResult(Object result)
{
if (result instanceof Boolean)
{
this.result = (Boolean) result;
return true; // abort other handler methods
}
if (result instanceof RenderCommand)
{
RenderCommand command = (RenderCommand) result;
add(command);
return false; // do not abort!
}
if (result instanceof Renderable)
{
final Renderable renderable = (Renderable) result;
RenderCommand wrapper = new RenderCommand()
{
public void render(MarkupWriter writer, RenderQueue queue)
{
renderable.render(writer);
}
};
add(wrapper);
return false;
}
throw new RuntimeException(StructureMessages.wrongPhaseResultType(Boolean.class));
}
private void add(RenderCommand command)
{
if (commands == null) commands = CollectionFactory.newList();
commands.add(command);
}
public void queueCommands(RenderQueue queue)
{
if (commands == null) return;
for (RenderCommand command : commands)
queue.push(command);
}
}
private final RenderCommand afterRender = new RenderCommand()
{
public void render(final MarkupWriter writer, RenderQueue queue)
{
RenderPhaseEventHandler handler = new RenderPhaseEventHandler();
final Event event = new EventImpl(handler, logger);
ComponentCallback callback = new ComponentCallback()
{
public void run(Component component)
{
component.afterRender(writer, event);
}
};
invoke(true, callback);
if (!handler.getResult()) queue.push(beginRender);
handler.queueCommands(queue);
}
@Override
public String toString()
{
return phaseToString("AfterRender");
}
};
private final RenderCommand afterRenderBody = new RenderCommand()
{
public void render(final MarkupWriter writer, RenderQueue queue)
{
RenderPhaseEventHandler handler = new RenderPhaseEventHandler();
final Event event = new EventImpl(handler, logger);
ComponentCallback callback = new ComponentCallback()
{
public void run(Component component)
{
component.afterRenderBody(writer, event);
}
};
invoke(true, callback);
if (!handler.getResult()) queue.push(beforeRenderBody);
handler.queueCommands(queue);
}
@Override
public String toString()
{
return phaseToString("AfterRenderBody");
}
};
private final RenderCommand afterRenderTemplate = new RenderCommand()
{
public void render(final MarkupWriter writer, final RenderQueue queue)
{
RenderPhaseEventHandler handler = new RenderPhaseEventHandler();
final Event event = new EventImpl(handler, logger);
ComponentCallback callback = new ComponentCallback()
{
public void run(Component component)
{
component.afterRenderTemplate(writer, event);
}
};
invoke(true, callback);
if (!handler.getResult()) queue.push(beforeRenderTemplate);
handler.queueCommands(queue);
}
@Override
public String toString()
{
return phaseToString("AfterRenderTemplate");
}
};
private final RenderCommand beforeRenderBody = new RenderCommand()
{
public void render(final MarkupWriter writer, RenderQueue queue)
{
RenderPhaseEventHandler handler = new RenderPhaseEventHandler();
final Event event = new EventImpl(handler, logger);
ComponentCallback callback = new ComponentCallback()
{
public void run(Component component)
{
component.beforeRenderBody(writer, event);
}
};
invoke(false, callback);
queue.push(afterRenderBody);
if (handler.getResult()) pushElements(queue, body);
handler.queueCommands(queue);
}
@Override
public String toString()
{
return phaseToString("BeforeRenderBody");
}
};
private final RenderCommand beforeRenderTemplate = new RenderCommand()
{
public void render(final MarkupWriter writer, final RenderQueue queue)
{
final RenderPhaseEventHandler handler = new RenderPhaseEventHandler();
final Event event = new EventImpl(handler, logger);
ComponentCallback callback = new ComponentCallback()
{
public void run(Component component)
{
component.beforeRenderTemplate(writer, event);
}
};
invoke(false, callback);
queue.push(afterRenderTemplate);
if (handler.getResult()) pushElements(queue, template);
handler.queueCommands(queue);
}
@Override
public String toString()
{
return phaseToString("BeforeRenderTemplate");
}
};
private final RenderCommand beginRender = new RenderCommand()
{
public void render(final MarkupWriter writer, final RenderQueue queue)
{
RenderPhaseEventHandler handler = new RenderPhaseEventHandler();
final Event event = new EventImpl(handler, logger);
ComponentCallback callback = new ComponentCallback()
{
public void run(Component component)
{
component.beginRender(writer, event);
}
};
invoke(false, callback);
queue.push(afterRender);
// If the component has no template whatsoever, then a
// renderBody element is added as the lone element of the component's template.
// So every component will have a non-empty template.
if (handler.getResult()) queue.push(beforeRenderTemplate);
handler.queueCommands(queue);
}
@Override
public String toString()
{
return phaseToString("BeginRender");
}
};
private Map<String, Block> blocks;
private List<PageElement> body;
private Map<String, ComponentPageElement> children;
private final String elementName;
private final PageResources pageResources;
private final Logger logger;
private final RenderCommand cleanupRender = new RenderCommand()
{
public void render(final MarkupWriter writer, RenderQueue queue)
{
RenderPhaseEventHandler handler = new RenderPhaseEventHandler();
final Event event = new EventImpl(handler, logger);
ComponentCallback callback = new ComponentCallback()
{
public void run(Component component)
{
component.cleanupRender(writer, event);
}
};
invoke(true, callback);
if (handler.getResult())
{
rendering = false;
Element current = writer.getElement();
if (current != elementAtSetup)
throw new TapestryException(StructureMessages.unbalancedElements(completeId), getLocation(), null);
elementAtSetup = null;
invoke(false, POST_RENDER_CLEANUP);
// NOW and only now the component is done rendering and fully cleaned up. Decrement
// the page's dirty count. If the entire render goes well, then the page will be
// clean and can be stored into the pool for later reuse.
page.decrementDirtyCount();
}
else
{
queue.push(setupRender);
}
handler.queueCommands(queue);
}
@Override
public String toString()
{
return phaseToString("CleanupRender");
}
};
private final String completeId;
// The user-provided class, with runtime code enhancements. In a component with mixins, this
// is the component to which the mixins are attached.
private final Component coreComponent;
/**
* Component lifecycle instances for all mixins; the core component is added to this list during page load. This is
* only used in the case that a component has mixins (in which case, the core component is listed last).
*/
private List<Component> components = null;
private final ComponentPageElement container;
private final InternalComponentResources coreResources;
private final String id;
private boolean loaded;
/**
* Map from mixin id (the simple name of the mixin class) to resources for the mixin. Created when first mixin is
* added.
*/
private Map<String, InternalComponentResources> mixinIdToComponentResources;
private final String nestedId;
private final Page page;
private boolean rendering;
/**
* Used to detect mismatches calls to {@link MarkupWriter#element(String, Object[])} } and {@link
* org.apache.tapestry5.MarkupWriter#end()}. The expectation is that any element(s) begun by this component during
* rendering will be balanced by end() calls, resulting in the current element reverting to its initial value.
*/
private Element elementAtSetup;
private final RenderCommand setupRender = new RenderCommand()
{
public void render(final MarkupWriter writer, RenderQueue queue)
{
// TODO: Check for recursive rendering.
rendering = true;
elementAtSetup = writer.getElement();
RenderPhaseEventHandler handler = new RenderPhaseEventHandler();
final Event event = new EventImpl(handler, logger);
ComponentCallback callback = new ComponentCallback()
{
public void run(Component component)
{
component.setupRender(writer, event);
}
};
invoke(false, callback);
queue.push(cleanupRender);
if (handler.getResult()) queue.push(beginRender);
handler.queueCommands(queue);
}
@Override
public String toString()
{
return phaseToString("SetupRender");
}
};
// We know that, at the very least, there will be an element to force the component to render
// its body, so there's no reason to wait to initialize the list.
private final List<PageElement> template = CollectionFactory.newList();
public ComponentPageElement newChild(String id, String elementName, Instantiator instantiator, Location location)
{
ComponentPageElementImpl child = new ComponentPageElementImpl(page, this, id, elementName, instantiator,
location, pageResources);
addEmbeddedElement(child);
return child;
}
/**
* Constructor for other components embedded within the root component or at deeper levels of the hierarchy.
*
* @param page ultimately containing this component
* @param container component immediately containing this component (may be null for a root component)
* @param id unique (within the container) id for this component (may be null for a root component)
* @param elementName the name of the element which represents this component in the template, or null for
* <comp> element or a page component
* @param instantiator used to create the new component instance and access the component's model
* @param location location of the element (within a template), used as part of exception reporting
* @param pageResources Provides access to common methods of various services
*/
ComponentPageElementImpl(Page page, ComponentPageElement container, String id, String elementName,
Instantiator instantiator, Location location, PageResources pageResources)
{
super(location);
this.page = page;
this.container = container;
this.id = id;
this.elementName = elementName;
this.pageResources = pageResources;
ComponentResources containerResources = container == null
? null
: container.getComponentResources();
String pageName = this.page.getLogicalName();
// A page (really, the root component of a page) does not have a container.
if (container == null)
{
completeId = pageName;
nestedId = null;
}
else
{
String caselessId = id.toLowerCase();
String parentNestedId = container.getNestedId();
// The root element has no nested id.
// The children of the root element have an id.
if (parentNestedId == null)
{
nestedId = caselessId;
completeId = pageName + ":" + caselessId;
}
else
{
nestedId = parentNestedId + "." + caselessId;
completeId = container.getCompleteId() + "." + caselessId;
}
}
coreResources = new InternalComponentResourcesImpl(this.page, this, containerResources, this.pageResources,
completeId, nestedId, instantiator);
coreComponent = coreResources.getComponent();
logger = coreResources.getLogger();
}
/**
* Constructor for the root component of a page.
*/
public ComponentPageElementImpl(Page page, Instantiator instantiator, PageResources pageResources)
{
this(page, null, null, null, instantiator, null, pageResources);
}
public void addEmbeddedElement(ComponentPageElement child)
{
if (children == null) children = CollectionFactory.newCaseInsensitiveMap();
String childId = child.getId();
ComponentPageElement existing = children.get(childId);
if (existing != null)
throw new TapestryException(StructureMessages.duplicateChildComponent(this, childId), child, null);
children.put(childId, child);
}
public void addMixin(Instantiator instantiator)
{
if (mixinIdToComponentResources == null)
{
mixinIdToComponentResources = CollectionFactory.newCaseInsensitiveMap();
components = CollectionFactory.newList();
}
String mixinClassName = instantiator.getModel().getComponentClassName();
String mixinName = TapestryInternalUtils.lastTerm(mixinClassName);
String mixinExtension = "$" + mixinName.toLowerCase();
InternalComponentResourcesImpl resources = new InternalComponentResourcesImpl(page, this, coreResources,
pageResources,
completeId + mixinExtension,
nestedId + mixinExtension,
instantiator);
// TODO: Check for name collision?
mixinIdToComponentResources.put(mixinName, resources);
components.add(resources.getComponent());
}
public void bindParameter(String parameterName, Binding binding)
{
// Maybe should use colon here? Depends on what works best in the template,
// don't want to lock this out as just
int dotx = parameterName.lastIndexOf('.');
if (dotx > 0)
{
String mixinName = parameterName.substring(0, dotx);
InternalComponentResources mixinResources = InternalUtils.get(mixinIdToComponentResources, mixinName);
if (mixinResources == null) throw new TapestryException(
StructureMessages.missingMixinForParameter(completeId, mixinName, parameterName), binding, null);
String simpleName = parameterName.substring(dotx + 1);
mixinResources.bindParameter(simpleName, binding);
return;
}
InternalComponentResources informalParameterResources = null;
// Does it match a formal parameter name of the core component? That takes precedence
if (coreResources.getComponentModel().getParameterModel(parameterName) != null)
{
coreResources.bindParameter(parameterName, binding);
return;
}
for (String mixinName : InternalUtils.sortedKeys(mixinIdToComponentResources))
{
InternalComponentResources resources = mixinIdToComponentResources.get(mixinName);
if (resources.getComponentModel().getParameterModel(parameterName) != null)
{
resources.bindParameter(parameterName, binding);
return;
}
if (informalParameterResources == null && resources.getComponentModel().getSupportsInformalParameters())
informalParameterResources = resources;
}
// An informal parameter
if (informalParameterResources == null && coreResources.getComponentModel().getSupportsInformalParameters())
informalParameterResources = coreResources;
// For the moment, informal parameters accumulate in the core component's resources, but
// that will likely change.
if (informalParameterResources != null) informalParameterResources.bindParameter(parameterName, binding);
}
public void addToBody(PageElement element)
{
if (body == null) body = CollectionFactory.newList();
body.add(element);
}
public void addToTemplate(PageElement element)
{
template.add(element);
}
private void addUnboundParameterNames(String prefix, List<String> unbound, InternalComponentResources resource)
{
ComponentModel model = resource.getComponentModel();
for (String name : model.getParameterNames())
{
if (resource.isBound(name)) continue;
ParameterModel parameterModel = model.getParameterModel(name);
if (parameterModel.isRequired())
{
String fullName = prefix == null ? name : prefix + "." + name;
unbound.add(fullName);
}
}
}
public void containingPageDidAttach()
{
invoke(false, CONTAINING_PAGE_DID_ATTACH);
}
public void containingPageDidDetach()
{
invoke(false, CONTAINING_PAGE_DID_DETACH);
}
public void containingPageDidLoad()
{
// If this component has mixins, add the core component to the end of the list, after the
// mixins.
if (components != null)
{
List<Component> ordered = CollectionFactory.newList();
Iterator<Component> i = components.iterator();
// Add all the normal components to the final list.
while (i.hasNext())
{
Component mixin = i.next();
if (mixin.getComponentResources().getComponentModel().isMixinAfter()) continue;
ordered.add(mixin);
// Remove from list, leaving just the late executing mixins
i.remove();
}
ordered.add(coreComponent);
// Add the remaining, late executing mixins
ordered.addAll(components);
components = ordered;
}
loaded = true;
// For some parameters, bindings (from defaults) are provided inside the callback method, so
// that is invoked first, before we check for unbound parameters.
invoke(false, CONTAINING_PAGE_DID_LOAD);
verifyRequiredParametersAreBound();
}
public void enqueueBeforeRenderBody(RenderQueue queue)
{
// If no body, then no beforeRenderBody or afterRenderBody
if (body != null) queue.push(beforeRenderBody);
}
public String getCompleteId()
{
return completeId;
}
public Component getComponent()
{
return coreComponent;
}
public InternalComponentResources getComponentResources()
{
return coreResources;
}
public ComponentPageElement getContainerElement()
{
return container;
}
public Page getContainingPage()
{
return page;
}
public ComponentPageElement getEmbeddedElement(String embeddedId)
{
ComponentPageElement embeddedElement = InternalUtils.get(children, embeddedId
.toLowerCase());
if (embeddedElement == null)
{
Set<String> ids = children == null ? null : children.keySet();
throw new TapestryException(StructureMessages.noSuchComponent(this, embeddedId, ids), this, null);
}
return embeddedElement;
}
public String getId()
{
return id;
}
public Logger getLogger()
{
return coreResources.getLogger();
}
public Component getMixinByClassName(String mixinClassName)
{
Component result = null;
if (mixinIdToComponentResources != null)
{
for (InternalComponentResources resources : mixinIdToComponentResources.values())
{
if (resources.getComponentModel().getComponentClassName().equals(mixinClassName))
{
result = resources.getComponent();
break;
}
}
}
if (result == null) throw new TapestryException(StructureMessages.unknownMixin(completeId, mixinClassName),
getLocation(), null);
return result;
}
public ComponentResources getMixinResources(String mixinId)
{
ComponentResources result = null;
if (mixinIdToComponentResources != null)
result = mixinIdToComponentResources.get(mixinId);
if (result == null)
throw new IllegalArgumentException(
String.format("Unable to locate mixin '%s' for component '%s'.", mixinId, completeId));
return result;
}
public String getNestedId()
{
return nestedId;
}
public boolean dispatchEvent(ComponentEvent event)
{
if (components == null) return coreComponent.dispatchComponentEvent(event);
// Otherwise, iterate over mixins + core component
boolean result = false;
for (Component component : components)
{
result |= component.dispatchComponentEvent(event);
if (event.isAborted()) break;
}
return result;
}
/**
* Invokes a callback on the component instances (the core component plus any mixins).
*
* @param reverse if true, the callbacks are in the reverse of the normal order (this is associated with AfterXXX
* phases)
* @param callback the object to receive each component instance
*/
private void invoke(boolean reverse, ComponentCallback callback)
{
try
{ // Optimization: In the most general case (just the one component, no mixins)
// invoke the callback on the component and be done ... no iterators, no nothing.
if (components == null)
{
callback.run(coreComponent);
return;
}
Iterator<Component> i = reverse ? InternalUtils.reverseIterator(components) : components.iterator();
while (i.hasNext()) callback.run(i.next());
}
catch (RuntimeException ex)
{
throw new TapestryException(ex.getMessage(), getLocation(), ex);
}
}
public boolean isLoaded()
{
return loaded;
}
public boolean isRendering()
{
return rendering;
}
/**
* Generate a toString() for the inner classes that represent render phases.
*/
private String phaseToString(String phaseName)
{
return String.format("%s[%s]", phaseName, completeId);
}
/**
* Pushes the SetupRender phase state onto the queue.
*/
public final void render(MarkupWriter writer, RenderQueue queue)
{
// TODO: An error if the _render flag is already set (recursive rendering not
// allowed or advisable).
// Once we start rendering, the page is considered dirty, until we cleanup post render.
page.incrementDirtyCount();
queue.startComponent(coreResources);
// POP_COMPONENT_ID will remove the component we just started.
queue.push(POP_COMPONENT_ID);
// This is the start of the real state machine for the component.
queue.push(setupRender);
}
@Override
public String toString()
{
return String.format("ComponentPageElement[%s]", completeId);
}
public boolean triggerEvent(String eventType, Object[] contextValues, ComponentEventCallback callback)
{
return triggerContextEvent(eventType,
createParameterContext(contextValues == null ? new Object[0] : contextValues),
callback);
}
private EventContext createParameterContext(final Object... values)
{
return new EventContext()
{
public int getCount()
{
return values.length;
}
public <T> T get(Class<T> desiredType, int index)
{
return pageResources.coerce(values[index], desiredType);
}
};
}
public boolean triggerContextEvent(String eventType, EventContext context, ComponentEventCallback callback)
{
Defense.notBlank(eventType, "eventType");
Defense.notNull(context, "context");
boolean result = false;
ComponentPageElement component = this;
String componentId = "";
// Provide a default handler for when the provided handler is null.
final ComponentEventCallback providedHandler = callback == null ? new NotificationEventCallback(eventType,
completeId) : callback;
ComponentEventCallback wrapped = new ComponentEventCallback()
{
public boolean handleResult(Object result)
{
// Boolean value is not passed to the handler; it will be true (abort event)
// or false (continue looking for event handlers).
if (result instanceof Boolean) return (Boolean) result;
return providedHandler.handleResult(result);
}
};
RuntimeException rootException = null;
// Because I don't like to reassign parameters.
String currentEventType = eventType;
EventContext currentContext = context;
// Track the location of the original component for the event, even as we work our way up
// the hierarchy. This may not be ideal if we trigger an "exception" event ... or maybe
// it's right (it's the location of the originally thrown exception).
Location location = component.getComponentResources().getLocation();
while (component != null)
{
try
{
Logger logger = component.getLogger();
ComponentEvent event = new ComponentEventImpl(currentEventType, componentId, currentContext, wrapped,
pageResources, logger);
if (logger.isDebugEnabled())
logger.debug("Dispatch event: " + event);
result |= component.dispatchEvent(event);
if (event.isAborted()) return result;
}
catch (RuntimeException ex)
{
// An exception in an event handler method
// while we're trying to handle a previous exception!
if (rootException != null) throw rootException;
// We know component is not null and therefore has a component resources that
// should have a location.
// Wrap it up to help ensure that a location is available to the event handler method or,
// more likely, to the exception report page.
rootException = new ComponentEventException(ex.getMessage(), eventType, context, location, ex);
// Switch over to triggering an "exception" event, starting in the component that
// threw the exception.
currentEventType = "exception";
currentContext = createParameterContext(rootException);
continue;
}
// On each bubble up, make the event appear to come from the previous component
// in which the event was triggered.
componentId = component.getId();
component = component.getContainerElement();
}
// If there was a handler for the exception event, it is required to return a non-null (and non-boolean) value
// to tell Tapestry what to do. Since that didn't happen, we have no choice but to rethrow the (wrapped)
// exception.
if (rootException != null) throw rootException;
return result;
}
private void verifyRequiredParametersAreBound()
{
List<String> unbound = CollectionFactory.newList();
addUnboundParameterNames(null, unbound, coreResources);
for (String name : InternalUtils.sortedKeys(mixinIdToComponentResources))
addUnboundParameterNames(name, unbound, mixinIdToComponentResources.get(name));
if (unbound.isEmpty()) return;
throw new TapestryException(StructureMessages.missingParameters(unbound, this), this, null);
}
public Locale getLocale()
{
return page.getLocale();
}
public String getElementName(String defaultElementName)
{
return elementName != null ? elementName : defaultElementName;
}
public Block getBlock(String id)
{
Block result = findBlock(id);
if (result == null)
throw new BlockNotFoundException(StructureMessages.blockNotFound(completeId, id), getLocation());
return result;
}
public Block findBlock(String id)
{
notBlank(id, "id");
return InternalUtils.get(blocks, id);
}
public void addBlock(String blockId, Block block)
{
if (blocks == null) blocks = CollectionFactory.newCaseInsensitiveMap();
if (blocks.containsKey(blockId))
throw new TapestryException(StructureMessages.duplicateBlock(this, blockId), block, null);
blocks.put(blockId, block);
}
public String getDefaultBindingPrefix(String parameterName)
{
int dotx = parameterName.lastIndexOf('.');
if (dotx > 0)
{
String mixinName = parameterName.substring(0, dotx);
InternalComponentResources mixinResources = InternalUtils.get(mixinIdToComponentResources, mixinName);
if (mixinResources == null) throw new TapestryException(
StructureMessages.missingMixinForParameter(completeId, mixinName, parameterName), null, null);
String simpleName = parameterName.substring(dotx + 1);
ParameterModel pm = mixinResources.getComponentModel().getParameterModel(simpleName);
return pm != null ? pm.getDefaultBindingPrefix() : null;
}
// A formal parameter of the core component?
ParameterModel pm = coreResources.getComponentModel().getParameterModel(parameterName);
if (pm != null) return pm.getDefaultBindingPrefix();
// Search for mixin that it is a formal parameter of
for (String mixinName : InternalUtils.sortedKeys(mixinIdToComponentResources))
{
InternalComponentResources resources = mixinIdToComponentResources.get(mixinName);
pm = resources.getComponentModel().getParameterModel(parameterName);
if (pm != null) return pm.getDefaultBindingPrefix();
}
// Not a formal parameter of the core component or any mixin.
return null;
}
public String getPageName()
{
return page.getLogicalName();
}
public boolean hasBody()
{
return body != null;
}
public Map<String, Binding> getInformalParameterBindings()
{
return coreResources.getInformalParameterBindings();
}
}
The table below shows all metrics for ComponentPageElementImpl.java.
| Metric | Value | Description | |
|---|---|---|---|
| BLOCKS | 114.00 | Number of blocks | |
| BLOCK_COMMENT | 0.00 | Number of block comment lines | |
| COMMENTS | 129.00 | Comment lines | |
| COMMENT_DENSITY | 0.25 | Comment density | |
| COMPARISONS | 73.00 | Number of comparison operators | |
| CYCLOMATIC | 154.00 | Cyclomatic complexity | |
| DECL_COMMENTS | 26.00 | Comments in declarations | |
| DOC_COMMENT | 55.00 | Number of javadoc comment lines | |
| ELOC | 511.00 | Effective lines of code | |
| EXEC_COMMENTS | 35.00 | Comments in executable code | |
| EXITS | 118.00 | Procedure exits | |
| FUNCTIONS | 83.00 | Number of function declarations | |
| HALSTEAD_DIFFICULTY | 84.16 | Halstead difficulty | |
| HALSTEAD_EFFORT | 0.00 | Halstead effort | |
| INTERFACE_COMPLEXITY | 195.00 | Interface complexity | |
| JAVA0001 | 1.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 | 1.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 | 37.00 | JAVA0034 Missing braces in if statement | |
| JAVA0035 | 1.00 | JAVA0035 Missing braces in for statement | |
| JAVA0036 | 1.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 | 0.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 | 0.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 | 5.00 | JAVA0075 Method parameter hides field | |
| JAVA0076 | 0.00 | JAVA0076 Use of magic number | |
| JAVA0077 | 5.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 | 0.00 | JAVA0081 Boolean literal in comparison | |
| JAVA0082 | 0.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 | 4.00 | JAVA0108 Incorrect javadoc: no @param tag for 'parameter' | |
| JAVA0109 | 0.00 | JAVA0109 Incorrect javadoc: no parameter 'parameter' | |
| JAVA0110 | 1.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 | 1.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 | 1.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 | 0.00 | JAVA0126 Method declares unchecked exception in throws | |
| JAVA0128 | 0.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 | 0.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 | 1.00 | JAVA0137 Non-abstract class missing constructor | |
| JAVA0138 | 1.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 | 0.00 | JAVA0144 Line exceeds maximum M characters | |
| JAVA0145 | 0.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 | 2.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 | 0.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 | 0.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 | 0.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 | 1.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 | 0.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 | 1188.00 | Number of lines in the source file | |
| LINE_COMMENT | 74.00 | Number of line comments | |
| LOC | 766.00 | Lines of code | |
| LOGICAL_LINES | 333.00 | Number of statements | |
| LOOPS | 4.00 | Number of loops | |
| NEST_DEPTH | 4.00 | Maximum nesting depth | |
| OPERANDS | 1518.00 | Number of operands | |
| OPERATORS | 2799.00 | Number of operators | |
| PARAMS | 87.00 | Number of formal parameter declarations | |
| PROGRAM_LENGTH | 4317.00 | Halstead program length | |
| PROGRAM_VOCAB | 551.00 | Halstead program vocabulary | |
| PROGRAM_VOLUME | 0.00 | Halstead program volume | |
| RETURNS | 108.00 | Number of return points from functions | |
| SIZE | 38184.00 | Size of the file in bytes | |
| UNIQUE_OPERANDS | 496.00 | Number of unique operands | |
| UNIQUE_OPERATORS | 55.00 | Number of unique operators | |
| WHITESPACE | 293.00 | Number of whitespace lines | |