Clover coverage report - Code Coverage for tapestry release 4.0-beta-6
Coverage timestamp: Wed Sep 7 2005 18:41:34 EDT
file stats: LOC: 111   Methods: 4
NCLOC: 47   Classes: 1
 
 Source file Conditionals Statements Methods TOTAL
BaseComponent.java 80% 90% 100% 88.2%
coverage coverage
 1    // Copyright 2004, 2005 The Apache Software Foundation
 2    //
 3    // Licensed under the Apache License, Version 2.0 (the "License");
 4    // you may not use this file except in compliance with the License.
 5    // You may obtain a copy of the License at
 6    //
 7    // http://www.apache.org/licenses/LICENSE-2.0
 8    //
 9    // Unless required by applicable law or agreed to in writing, software
 10    // distributed under the License is distributed on an "AS IS" BASIS,
 11    // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 12    // See the License for the specific language governing permissions and
 13    // limitations under the License.
 14   
 15    package org.apache.tapestry;
 16   
 17    import org.apache.commons.logging.Log;
 18    import org.apache.commons.logging.LogFactory;
 19    import org.apache.tapestry.engine.IPageLoader;
 20    import org.apache.tapestry.spec.IComponentSpecification;
 21   
 22    /**
 23    * Base implementation for most components that use an HTML template.
 24    *
 25    * @author Howard Lewis Ship
 26    */
 27   
 28    public class BaseComponent extends AbstractComponent implements ITemplateComponent
 29    {
 30    private static final Log LOG = LogFactory.getLog(BaseComponent.class);
 31   
 32    private static final int OUTER_INIT_SIZE = 5;
 33   
 34    private IRender[] _outer;
 35   
 36    private int _outerCount = 0;
 37   
 38    /**
 39    * Adds an element as an outer element for the receiver. Outer elements are elements that should
 40    * be directly rendered by the receiver's <code>render()</code> method. That is, they are
 41    * top-level elements on the HTML template.
 42    */
 43   
 44  815 public void addOuter(IRender element)
 45    {
 46  815 if (_outer == null)
 47    {
 48  214 _outer = new IRender[OUTER_INIT_SIZE];
 49  214 _outer[0] = element;
 50   
 51  214 _outerCount = 1;
 52  214 return;
 53    }
 54   
 55    // No more room? Make the array bigger.
 56   
 57  601 if (_outerCount == _outer.length)
 58    {
 59  57 IRender[] newOuter;
 60   
 61  57 newOuter = new IRender[_outer.length * 2];
 62   
 63  57 System.arraycopy(_outer, 0, newOuter, 0, _outerCount);
 64   
 65  57 _outer = newOuter;
 66    }
 67   
 68  601 _outer[_outerCount++] = element;
 69    }
 70   
 71    /**
 72    * Reads the receiver's template and figures out which elements wrap which other elements.
 73    */
 74   
 75  213 private void readTemplate(IRequestCycle cycle, IPageLoader loader)
 76    {
 77  213 loader.loadTemplateForComponent(cycle, this);
 78    }
 79   
 80    /**
 81    * Renders the top level components contained by the receiver.
 82    *
 83    * @since 2.0.3
 84    */
 85   
 86  238 protected void renderComponent(IMarkupWriter writer, IRequestCycle cycle)
 87    {
 88  238 if (LOG.isDebugEnabled())
 89  0 LOG.debug("Begin render " + getExtendedId());
 90   
 91  238 for (int i = 0; i < _outerCount; i++)
 92  876 _outer[i].render(writer, cycle);
 93   
 94  223 if (LOG.isDebugEnabled())
 95  0 LOG.debug("End render " + getExtendedId());
 96    }
 97   
 98    /**
 99    * Loads the template for the component, then invokes
 100    * {@link AbstractComponent#finishLoad(IRequestCycle, IPageLoader, IComponentSpecification)}.
 101    * Subclasses must invoke this method first, before adding any additional behavior, though its
 102    * usually simpler to override {@link #finishLoad()}instead.
 103    */
 104   
 105  213 public void finishLoad(IRequestCycle cycle, IPageLoader loader, IComponentSpecification specification)
 106    {
 107  213 readTemplate(cycle, loader);
 108   
 109  206 super.finishLoad(cycle, loader, specification);
 110    }
 111    }