Coverage report

  %line %branch
org.apache.commons.jelly.tags.threads.UseThreadTag
54% 
94% 

 1  
 /*
 2  
  * Copyright 2002,2004 The Apache Software Foundation.
 3  
  *
 4  
  * Licensed under the Apache License, Version 2.0 (the "License");
 5  
  * you may not use this file except in compliance with the License.
 6  
  * You may obtain a copy of the License at
 7  
  *
 8  
  *      http://www.apache.org/licenses/LICENSE-2.0
 9  
  *
 10  
  * Unless required by applicable law or agreed to in writing, software
 11  
  * distributed under the License is distributed on an "AS IS" BASIS,
 12  
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 13  
  * See the License for the specific language governing permissions and
 14  
  * limitations under the License.
 15  
  */
 16  
 
 17  
 package org.apache.commons.jelly.tags.threads;
 18  
 
 19  
 import org.apache.commons.jelly.JellyTagException;
 20  
 import org.apache.commons.jelly.TagSupport;
 21  
 import org.apache.commons.jelly.XMLOutput;
 22  
 
 23  
 import java.util.List;
 24  
 
 25  
 /**
 26  
  * Base class for tags that will "use" threads.
 27  
  *
 28  
  * @author <a href="mailto:jason@jhorman.org">Jason Horman</a>
 29  
  */
 30  
 
 31  110
 public abstract class UseThreadTag extends TagSupport {
 32  
     /** The thread to use in some way. */
 33  54
     private Thread thread = null;
 34  
     /** Threads can be grouped and acted on as a set */
 35  54
     private List threadGroup = null;
 36  
     /** If true doTag will search for a parent thread to use if setThread was not called */
 37  54
     private boolean searchForParent = true;
 38  
 
 39  
     /**
 40  
      * The default behavior is to either use the set thread or to
 41  
      * search for a parent thread to use.
 42  
      */
 43  
     public void doTag(XMLOutput output) throws JellyTagException {
 44  
         try {
 45  
             // either use the set thread or search for a parent thread to use
 46  54
             if (thread != null) {
 47  24
                 useThread(thread, output);
 48  30
             } else if (threadGroup != null) {
 49  0
                 useThreadGroup(threadGroup, output);
 50  
             } else {
 51  
                 // check if this tag is nested inside a thread. if so
 52  
                 // use the parent thread.
 53  30
                 if (searchForParent) {
 54  
                     // first look for parent threads
 55  30
                     ThreadTag tt = (ThreadTag) findAncestorWithClass(ThreadTag.class);
 56  
 
 57  30
                     if (tt != null) {
 58  30
                         useThread(tt.getThread(), output);
 59  
                     } else {
 60  
                         // then look for parent thread groups
 61  0
                         GroupTag gt = (GroupTag) findAncestorWithClass(GroupTag.class);
 62  0
                         if (gt != null) {
 63  0
                             useThreadGroup(gt.getThreads(), output);
 64  
                         } else {
 65  0
                             throw new JellyTagException("no thread or thread group found");
 66  
                         }
 67  
                     }
 68  
                 } else {
 69  0
                     throw new JellyTagException("no thread or thread group found");
 70  
                 }
 71  
             }
 72  54
         }
 73  
         catch (InterruptedException e) {
 74  0
             throw new JellyTagException(e);
 75  
         }
 76  54
     }
 77  
 
 78  
     /** Implement this method to do something with the thread */
 79  
     protected abstract void useThread(Thread thread, XMLOutput output) throws InterruptedException ;
 80  
 
 81  
     /** Implement this method to do something with the threadGroup */
 82  
     protected abstract void useThreadGroup(List threadGroup, XMLOutput output) throws InterruptedException ;
 83  
 
 84  
     /**
 85  
      * Set the thread to use in some way.
 86  
      */
 87  
     public void setThread(Thread thread) {
 88  24
         this.thread = thread;
 89  24
     }
 90  
 
 91  
     /**
 92  
      * Get a reference to the thread to use
 93  
      */
 94  
     public Thread getThread() {
 95  0
         return thread;
 96  
     }
 97  
 
 98  
     /**
 99  
      * Set the thread group to "use".
 100  
      * @param threadGroup The threadGroup created with the <i>group</i> tag.
 101  
      */
 102  
     public void setThreadGroup(List threadGroup) {
 103  0
         this.threadGroup = threadGroup;
 104  0
     }
 105  
 
 106  
     /**
 107  
      * Get the thread group
 108  
      */
 109  
     public List getThreadGroup() {
 110  0
         return threadGroup;
 111  
     }
 112  
 
 113  
     /**
 114  
      * If true the tag will search for a parent thread tag to "use" if
 115  
      * no thread was set via <i>setThread</i>. This is <i>true</i> by default.
 116  
      */
 117  
     public void setSearchForParentThread(boolean searchForParent) {
 118  0
         this.searchForParent = searchForParent;
 119  0
     }
 120  
 }

This report is generated by jcoverage, Maven and Maven JCoverage Plugin.