Coverage report

  %line %branch
org.apache.turbine.services.intake.xmlmodel.XmlGroup
0% 
0% 

 1  
 package org.apache.turbine.services.intake.xmlmodel;
 2  
 
 3  
 /*
 4  
  * Copyright 2001-2005 The Apache Software Foundation.
 5  
  *
 6  
  * Licensed under the Apache License, Version 2.0 (the "License")
 7  
  * you may not use this file except in compliance with the License.
 8  
  * You may obtain a copy of the License at
 9  
  *
 10  
  *     http://www.apache.org/licenses/LICENSE-2.0
 11  
  *
 12  
  * Unless required by applicable law or agreed to in writing, software
 13  
  * distributed under the License is distributed on an "AS IS" BASIS,
 14  
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 15  
  * See the License for the specific language governing permissions and
 16  
  * limitations under the License.
 17  
  */
 18  
 
 19  
 import java.io.Serializable;
 20  
 
 21  
 import java.util.ArrayList;
 22  
 import java.util.Iterator;
 23  
 import java.util.List;
 24  
 
 25  
 import org.apache.commons.lang.StringUtils;
 26  
 
 27  
 import org.xml.sax.Attributes;
 28  
 
 29  
 /**
 30  
  * A Class for holding data about a grouping of inputs used in an Application.
 31  
  *
 32  
  * @author <a href="mailto:jmcnally@collab.net>John McNally</a>
 33  
  * @version $Id: XmlGroup.java 278822 2005-09-05 19:53:05Z henning $
 34  
  */
 35  
 public class XmlGroup
 36  
         implements Serializable
 37  
 {
 38  
     /** Serial Version UID */
 39  
     private static final long serialVersionUID = -2529039710689787681L;
 40  
 
 41  
     private List fields;
 42  
     private List mapToObjects;
 43  
     private String defaultMapToObject;
 44  
     private AppData parent;
 45  
     private String groupName;
 46  
     private String key;
 47  
     private String poolCapacity;
 48  
 
 49  
     /**
 50  
      * Constructs a input group object
 51  
      */
 52  
     public XmlGroup()
 53  0
     {
 54  0
         fields = new ArrayList();
 55  0
         mapToObjects = new ArrayList(2);
 56  0
     }
 57  
 
 58  
     /**
 59  
      * Load the input group object from an xml tag.
 60  
      */
 61  
     public void loadFromXML(Attributes attrib)
 62  
     {
 63  0
         groupName = attrib.getValue("name");
 64  0
         key = attrib.getValue("key");
 65  0
         poolCapacity = attrib.getValue("pool-capacity");
 66  
 
 67  0
         String objName = attrib.getValue("mapToObject");
 68  0
         if (StringUtils.isNotEmpty(objName))
 69  
         {
 70  0
             defaultMapToObject = objName;
 71  
         }
 72  0
     }
 73  
 
 74  
     /**
 75  
      * Get the name that handles this group
 76  
      */
 77  
     public String getName()
 78  
     {
 79  0
         return groupName;
 80  
     }
 81  
 
 82  
     /**
 83  
      * Set the name that handles this group
 84  
      */
 85  
     public void setName(String newGroupName)
 86  
     {
 87  0
         groupName = newGroupName;
 88  0
     }
 89  
 
 90  
     /**
 91  
      * Get the key used to reference this group in input (form)
 92  
      */
 93  
     public String getKey()
 94  
     {
 95  0
         return key;
 96  
     }
 97  
 
 98  
     /**
 99  
      * Set the key used to reference this group in input (form)
 100  
      */
 101  
     public void setKey(String newKey)
 102  
     {
 103  0
         key = newKey;
 104  0
     }
 105  
 
 106  
     /**
 107  
      * The maximum number of classes specific to this group
 108  
      * allowed at one time.
 109  
      *
 110  
      * @return an <code>String</code> value
 111  
      */
 112  
     public String getPoolCapacity()
 113  
     {
 114  0
         if (poolCapacity == null)
 115  
         {
 116  0
             return "128";
 117  
         }
 118  
 
 119  0
         return poolCapacity;
 120  
     }
 121  
 
 122  
     /**
 123  
      * A utility function to create a new field
 124  
      * from attrib and add it to this input group.
 125  
      */
 126  
     public XmlField addField(Attributes attrib)
 127  
     {
 128  0
         XmlField field = new XmlField();
 129  0
         field.loadFromXML(attrib);
 130  0
         addField(field);
 131  
 
 132  0
         return field;
 133  
     }
 134  
 
 135  
     /**
 136  
      * Adds a new field to the fields list and set the
 137  
      * parent group of the field to the current group
 138  
      */
 139  
     public void addField(XmlField field)
 140  
     {
 141  0
         field.setGroup(this);
 142  
 
 143  
         // if this field has an object defined for mapping,
 144  
         // add it to the list
 145  0
         if (field.getMapToObject() != null)
 146  
         {
 147  0
             boolean isNewObject = true;
 148  0
             for (int i = 0; i < mapToObjects.size(); i++)
 149  
             {
 150  0
                 if (mapToObjects.get(i).equals(field.getMapToObject()))
 151  
                 {
 152  0
                     isNewObject = false;
 153  0
                     break;
 154  
                 }
 155  
             }
 156  0
             if (isNewObject)
 157  
             {
 158  0
                 mapToObjects.add(field.getMapToObject());
 159  
             }
 160  
         }
 161  
         // if a mapToProperty exists, set the object to this group's default
 162  0
         else if (field.getMapToProperty() != null
 163  
                 && !"".equals(field.getMapToProperty())
 164  
                 && defaultMapToObject != null)
 165  
         {
 166  0
             field.setMapToObject(defaultMapToObject);
 167  
         }
 168  
 
 169  0
         fields.add(field);
 170  0
     }
 171  
 
 172  
     /**
 173  
      * Returns a collection of fields in this input group
 174  
      */
 175  
     public List getFields()
 176  
     {
 177  0
         return fields;
 178  
     }
 179  
 
 180  
     /**
 181  
      * Utility method to get the number of fields in this input group
 182  
      */
 183  
     public int getNumFields()
 184  
     {
 185  0
         return fields.size();
 186  
     }
 187  
 
 188  
     /**
 189  
      * Returns a Specified field.
 190  
      * @return Return a XmlField object or null if it does not exist.
 191  
      */
 192  
     public XmlField getField(String name)
 193  
     {
 194  
         String curName;
 195  
 
 196  0
         for (Iterator iter = fields.iterator(); iter.hasNext();)
 197  
         {
 198  0
             XmlField field = (XmlField) iter.next();
 199  0
             curName = field.getRawName();
 200  0
             if (curName.equals(name))
 201  
             {
 202  0
                 return field;
 203  
             }
 204  
         }
 205  0
         return null;
 206  
     }
 207  
 
 208  
     /**
 209  
      * Returns true if the input group contains a spesified field
 210  
      */
 211  
     public boolean containsField(XmlField field)
 212  
     {
 213  0
         return fields.contains(field);
 214  
     }
 215  
 
 216  
     /**
 217  
      * Returns true if the input group contains a specified field
 218  
      */
 219  
     public boolean containsField(String name)
 220  
     {
 221  0
         return (getField(name) != null);
 222  
     }
 223  
 
 224  
     public List getMapToObjects()
 225  
     {
 226  0
         return mapToObjects;
 227  
     }
 228  
 
 229  
     /**
 230  
      * Set the parent of the group
 231  
      */
 232  
     public void setAppData(AppData parent)
 233  
     {
 234  0
         this.parent = parent;
 235  0
         if (defaultMapToObject != null)
 236  
         {
 237  0
             defaultMapToObject = parent.getBasePackage() + defaultMapToObject;
 238  0
             mapToObjects.add(defaultMapToObject);
 239  
         }
 240  0
     }
 241  
 
 242  
     /**
 243  
      * Get the parent of the input group
 244  
      */
 245  
     public AppData getAppData()
 246  
     {
 247  0
         return parent;
 248  
     }
 249  
 
 250  
     /**
 251  
      * A String which might be used as a variable of this class
 252  
      */
 253  
     public String getVariable()
 254  
     {
 255  0
         String firstChar = getName().substring(0, 1).toLowerCase();
 256  0
         return firstChar + getName().substring(1);
 257  
     }
 258  
 
 259  
     /**
 260  
      * Creates a string representation of this input group. This
 261  
      * is an xml representation.
 262  
      */
 263  
     public String toString()
 264  
     {
 265  0
         StringBuffer result = new StringBuffer();
 266  
 
 267  0
         result.append("<group name=\"").append(getName());
 268  0
         result.append(" key=\"" + key + "\"");
 269  0
         result.append(">\n");
 270  
 
 271  0
         if (fields != null)
 272  
         {
 273  0
             for (Iterator iter = fields.iterator(); iter.hasNext();)
 274  
             {
 275  0
                 result.append(iter.next());
 276  
             }
 277  
         }
 278  
 
 279  0
         result.append("</group>\n");
 280  
 
 281  0
         return result.toString();
 282  
     }
 283  
 }

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