Coverage report

  %line %branch
org.apache.commons.jexl.parser.SimpleNode
50% 
89% 

 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.jexl.parser;
 18  
 
 19  
 import org.apache.commons.jexl.JexlContext;
 20  
 
 21  
 /**
 22  
  *  useful interface to node. most autogened by javacc
 23  
  *
 24  
  *  @author <a href="mailto:geirm@apache.org">Geir Magnusson Jr.</a>
 25  
  *  @version $Id: SimpleNode.java,v 1.3 2004/02/28 13:45:21 yoavs Exp $
 26  
  */
 27  
 public class SimpleNode implements Node
 28  
 {
 29  
     protected Node parent;
 30  
     protected Node[] children;
 31  
     protected int id;
 32  
     protected Parser parser;
 33  
 
 34  1435
     public SimpleNode(int i)
 35  19550
     {
 36  20985
         id = i;
 37  20985
     }
 38  
 
 39  
     public SimpleNode(Parser p, int i)
 40  
     {
 41  20985
         this(i);
 42  20985
         parser = p;
 43  20985
     }
 44  
 
 45  
     public void jjtOpen()
 46  
     {
 47  20985
     }
 48  
 
 49  
     public void jjtClose()
 50  
     {
 51  17988
     }
 52  
 
 53  
     public void jjtSetParent(Node n)
 54  
     {
 55  18117
         parent = n;
 56  18117
     }
 57  
 
 58  
     public Node jjtGetParent()
 59  
     {
 60  0
         return parent;
 61  
     }
 62  
 
 63  
     public void jjtAddChild(Node n, int i)
 64  
     {
 65  18117
         if (children == null)
 66  
         {
 67  14442
             children = new Node[i + 1];
 68  
         }
 69  3675
         else if (i >= children.length)
 70  
         {
 71  0
             Node c[] = new Node[i + 1];
 72  0
             System.arraycopy(children, 0, c, 0, children.length);
 73  0
             children = c;
 74  
         }
 75  
 
 76  18117
         children[i] = n;
 77  18117
     }
 78  
 
 79  
     public Node jjtGetChild(int i)
 80  
     {
 81  18105
         return  children[i];
 82  
     }
 83  
 
 84  
     public int jjtGetNumChildren()
 85  
     {
 86  5253
         return (children == null) ? 0 : children.length;
 87  
     }
 88  
 
 89  
     /** Accept the visitor. **/
 90  
     public Object jjtAccept(ParserVisitor visitor, Object data)
 91  
     {
 92  0
         return visitor.visit(this, data);
 93  
     }
 94  
 
 95  
     /** Accept the visitor. **/
 96  
     public Object childrenAccept(ParserVisitor visitor, Object data)
 97  
     {
 98  0
         if (children != null)
 99  
         {
 100  0
             for (int i = 0; i < children.length; ++i)
 101  
             {
 102  0
                 children[i].jjtAccept(visitor, data);
 103  
             }
 104  
         }
 105  0
         return data;
 106  
     }
 107  
 
 108  
 
 109  
     public String toString()
 110  
     {
 111  0
         return ParserTreeConstants.jjtNodeName[id];
 112  
     }
 113  
 
 114  
     public String toString(String prefix)
 115  
     {
 116  0
         return prefix + toString();
 117  
     }
 118  
 
 119  
     public void dump(String prefix)
 120  
     {
 121  0
         System.out.println(toString(prefix));
 122  
 
 123  0
         if (children != null)
 124  
         {
 125  0
             for (int i = 0; i < children.length; ++i)
 126  
             {
 127  0
                 SimpleNode n = (SimpleNode)children[i];
 128  
 
 129  0
                 if (n != null)
 130  
                 {
 131  0
                     n.dump(prefix + " ");
 132  
                 }
 133  
             }
 134  
         }
 135  0
     }
 136  
 
 137  
     /**
 138  
      *  basic interpret - just invoke interpret on all children
 139  
      */
 140  
     public boolean interpret(JexlContext pc)
 141  
         throws Exception
 142  
     {
 143  585
         for (int i=0; i<jjtGetNumChildren();i++)
 144  
         {
 145  270
             SimpleNode node = (SimpleNode) jjtGetChild(i);
 146  270
             if (!node.interpret(pc))
 147  0
                 return false;
 148  
         }
 149  
 
 150  315
         return true;
 151  
     }
 152  
 
 153  
 
 154  
     /**
 155  
      *  Returns the value of the node.
 156  
      */
 157  
     public Object value(JexlContext context)
 158  
             throws Exception
 159  
     {
 160  0
         return null;
 161  
     }
 162  
 
 163  
     /**
 164  
      *  Sets the value for the node - again, only makes sense for some nodes
 165  
      *  but lazyness tempts me to put it here.  Keeps things simple.
 166  
      */
 167  
     public Object setValue(JexlContext context, Object value)
 168  
         throws Exception
 169  
     {
 170  0
         return null;
 171  
     }
 172  
 
 173  
     /**
 174  
      *  Used to let a node calcuate it's value..
 175  
      */
 176  
     public Object execute(Object o, JexlContext ctx)
 177  
             throws Exception
 178  
     {
 179  0
         return null;
 180  
     }
 181  
 }
 182  
 

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