Clover coverage report - Code Coverage for tapestry release 4.0-alpha-3
Coverage timestamp: Mon May 16 2005 09:05:49 EDT
file stats: LOC: 111   Methods: 4
NCLOC: 47   Classes: 1
30 day Evaluation Version distributed via the Maven Jar Repository. Clover is not free. You have 30 days to evaluate it. Please visit http://www.thecortex.net/clover to obtain a licensed version of Clover
 
 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  836
     public void addOuter(IRender element)
 45   
     {
 46  836
         if (_outer == null)
 47   
         {
 48  228
             _outer = new IRender[OUTER_INIT_SIZE];
 49  228
             _outer[0] = element;
 50   
 
 51  228
             _outerCount = 1;
 52  228
             return;
 53   
         }
 54   
 
 55   
         // No more room? Make the array bigger.
 56   
 
 57  608
         if (_outerCount == _outer.length)
 58   
         {
 59  56
             IRender[] newOuter;
 60   
 
 61  56
             newOuter = new IRender[_outer.length * 2];
 62   
 
 63  56
             System.arraycopy(_outer, 0, newOuter, 0, _outerCount);
 64   
 
 65  56
             _outer = newOuter;
 66   
         }
 67   
 
 68  608
         _outer[_outerCount++] = element;
 69   
     }
 70   
 
 71   
     /**
 72   
      * Reads the receiver's template and figures out which elements wrap which other elements.
 73   
      */
 74   
 
 75  227
     private void readTemplate(IRequestCycle cycle, IPageLoader loader)
 76   
     {
 77  227
         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  263
     protected void renderComponent(IMarkupWriter writer, IRequestCycle cycle)
 87   
     {
 88  263
         if (LOG.isDebugEnabled())
 89  0
             LOG.debug("Begin render " + getExtendedId());
 90   
 
 91  263
         for (int i = 0; i < _outerCount; i++)
 92  893
             _outer[i].render(writer, cycle);
 93   
 
 94  245
         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  227
     public void finishLoad(IRequestCycle cycle, IPageLoader loader, IComponentSpecification specification)
 106   
     {
 107  227
         readTemplate(cycle, loader);
 108   
 
 109  220
         super.finishLoad(cycle, loader, specification);
 110   
     }
 111   
 }