Coverage Report - com.sun.javafx.api.tree.JavaFXTreeScanner
 
Classes in this File Line Coverage Branch Coverage Complexity
JavaFXTreeScanner
31%
20/65
N/A
0
 
 1  
 /*
 2  
  * Copyright 2005-2006 Sun Microsystems, Inc.  All Rights Reserved.
 3  
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 4  
  *
 5  
  * This code is free software; you can redistribute it and/or modify it
 6  
  * under the terms of the GNU General Public License version 2 only, as
 7  
  * published by the Free Software Foundation.  Sun designates this
 8  
  * particular file as subject to the "Classpath" exception as provided
 9  
  * by Sun in the LICENSE file that accompanied this code.
 10  
  *
 11  
  * This code is distributed in the hope that it will be useful, but WITHOUT
 12  
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 13  
  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 14  
  * version 2 for more details (a copy is included in the LICENSE file that
 15  
  * accompanied this code).
 16  
  *
 17  
  * You should have received a copy of the GNU General Public License version
 18  
  * 2 along with this work; if not, write to the Free Software Foundation,
 19  
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 20  
  *
 21  
  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
 22  
  * CA 95054 USA or visit www.sun.com if you need additional information or
 23  
  * have any questions.
 24  
  */
 25  
 
 26  
 package com.sun.javafx.api.tree;
 27  
 
 28  
 import com.sun.source.tree.*;
 29  
 import com.sun.source.util.TreeScanner;
 30  
 
 31  
 /**
 32  
  * A TreeVisitor that visits all the child tree nodes.
 33  
  * To visit nodes of a particular type, just override the
 34  
  * corresponding visitXYZ method.
 35  
  * Inside your method, call super.visitXYZ to visit descendant
 36  
  * nodes.  This class extends the TreeScanner class to add support
 37  
  * for JavaFX Script tree nodes.
 38  
  * 
 39  
  * @see com.sun.source.util.TreeScanner
 40  
  * @author Tom Ball
 41  
  */
 42  4
 public class JavaFXTreeScanner<R,P> extends TreeScanner<R,P> implements JavaFXTreeVisitor<R,P> {
 43  
 
 44  
     private R scanAndReduce(Tree node, P p, R r) {
 45  30
         return reduce(scan(node, p), r);
 46  
     }
 47  
 
 48  
     private R scanAndReduce(Iterable<? extends Tree> nodes, P p, R r) {
 49  9
         return reduce(scan(nodes, p), r);
 50  
     }
 51  
 
 52  
 /* ***************************************************************************
 53  
  * Visitor methods
 54  
  ****************************************************************************/
 55  
 
 56  
     public R visitBindExpression(BindExpressionTree node, P p) {
 57  0
         return scan(node.getExpression(), p);
 58  
     }
 59  
 
 60  
     public R visitBlockExpression(BlockExpressionTree node, P p) {
 61  3
         R r = scan(node.getStatements(), p);
 62  3
         return scanAndReduce(node.getValue(), p, r);
 63  
     }
 64  
 
 65  
     public R visitClassDeclaration(ClassDeclarationTree node, P p) {
 66  2
         R r = scan(node.getModifiers(), p);
 67  2
         r = scanAndReduce(node.getImplements(), p, r);
 68  2
         r = scanAndReduce(node.getExtends(), p, r);
 69  2
         return scanAndReduce(node.getClassMembers(), p, r);
 70  
     }
 71  
 
 72  
     public R visitForExpression(ForExpressionTree node, P p) {
 73  0
         R r = scan(node.getInClauses(), p);
 74  0
         return scanAndReduce(node.getBodyExpression(), p, r);
 75  
     }
 76  
 
 77  
     public R visitForExpressionInClause(ForExpressionInClauseTree node, P p) {
 78  0
         R r = scan(node.getVariable(), p);
 79  0
         r = scanAndReduce(node.getSequenceExpression(), p, r);
 80  0
         return scanAndReduce(node.getWhereExpression(), p, r);
 81  
     }
 82  
     
 83  
     public R visitIndexof(IndexofTree node, P p) {
 84  0
        return null;
 85  
     }
 86  
 
 87  
     public R visitInitDefinition(InitDefinitionTree node, P p) {
 88  0
         return scan(node.getBody(), p);
 89  
     }
 90  
 
 91  
     public R visitPostInitDefinition(InitDefinitionTree node, P p) {
 92  0
         return scan(node.getBody(), p);
 93  
     }
 94  
 
 95  
     public R visitInstantiate(InstantiateTree node, P p) {
 96  0
         R r = scan(node.getArguments(), p);
 97  0
         r = scanAndReduce(node.getClassBody(), p, r);
 98  0
         r = scanAndReduce(node.getIdentifier(), p, r);
 99  0
         return scanAndReduce(node.getLiteralParts(), p, r);
 100  
     }
 101  
 
 102  
     public R visitInterpolate(InterpolateTree node, P p) {
 103  0
         R r = scan(node.getVariable(), p);
 104  0
         return scanAndReduce(node.getInterpolateValues(), p, r);
 105  
     }
 106  
 
 107  
     public R visitInterpolateValue(InterpolateValueTree node, P p) {
 108  0
         R r = scan(node.getAttribute(), p);
 109  0
         return scanAndReduce(node.getValue(), p, r);
 110  
     }
 111  
 
 112  
     public R visitKeyFrameLiteral(KeyFrameLiteralTree node, P p) {
 113  0
         R r = scan(node.getStartDuration(), p);
 114  0
         r = scanAndReduce(node.getInterpolationExpression(), p, r);
 115  0
         return scanAndReduce(node.getTriggerExpression(), p, r);
 116  
     }
 117  
     public R visitObjectLiteralPart(ObjectLiteralPartTree node, P p) {
 118  0
         return scan(node.getExpression(), p);
 119  
     }
 120  
 
 121  
     public R visitOnReplace(OnReplaceTree node, P p) {
 122  0
         R r = scan(node.getOldValue(), p);
 123  0
         return scanAndReduce(node.getBody(), p, r);
 124  
     }
 125  
 
 126  
     public R visitTrigger(TriggerTree node, P p) {
 127  0
         R r = scan(node.getExpressionTree(), p);
 128  0
         return scanAndReduce(node.getOnReplaceTree(), p, r);
 129  
     }
 130  
 
 131  
     
 132  
     public R visitFunctionDefinition(FunctionDefinitionTree node, P p) {
 133  3
         R r = scan(node.getModifiers(), p);
 134  3
         return scanAndReduce(node.getFunctionValue(), p, r);
 135  
     }
 136  
 
 137  
     public R visitFunctionValue(FunctionValueTree node, P p) {
 138  3
         R r = scan(node.getType(), p);
 139  3
         r = scanAndReduce(node.getParameters(), p, r);
 140  3
         return scanAndReduce(node.getBodyExpression(), p, r);
 141  
     }
 142  
 
 143  
     public R visitSequenceDelete(SequenceDeleteTree node, P p) {
 144  0
         R r = scan(node.getSequence(), p);
 145  0
         return scanAndReduce(node.getElement(), p, r);
 146  
     }
 147  
 
 148  
     public R visitSequenceEmpty(SequenceEmptyTree node, P p) {
 149  0
         return null;
 150  
     }
 151  
 
 152  
     public R visitSequenceExplicit(SequenceExplicitTree node, P p) {
 153  0
         return scan(node.getItemList(), p);
 154  
     }
 155  
 
 156  
     public R visitSequenceIndexed(SequenceIndexedTree node, P p) {
 157  0
         R r = scan(node.getSequence(), p);
 158  0
         return scanAndReduce(node.getIndex(), p, r);
 159  
     }
 160  
 
 161  
     public R visitSequenceSlice(SequenceSliceTree node, P p) {
 162  0
         R r = scan(node.getSequence(), p);
 163  0
         r = scanAndReduce(node.getFirstIndex(), p, r);
 164  0
         return scanAndReduce(node.getLastIndex(), p, r);
 165  
     }
 166  
 
 167  
     public R visitSequenceInsert(SequenceInsertTree node, P p) {
 168  0
         R r = scan(node.getSequence(), p);
 169  0
         return scanAndReduce(node.getElement(), p, r);
 170  
     }
 171  
 
 172  
     public R visitSequenceRange(SequenceRangeTree node, P p) {
 173  0
         R r = scan(node.getLower(), p);
 174  0
         r = scanAndReduce(node.getUpper(), p, r);
 175  0
         return scanAndReduce(node.getStepOrNull(), p, r);
 176  
     }
 177  
 
 178  
     public R visitSetAttributeToObject(SetAttributeToObjectTree node, P p) {
 179  0
         return null;
 180  
     }
 181  
 
 182  
     public R visitStringExpression(StringExpressionTree node, P p) {
 183  0
         return scan(node.getPartList(), p);
 184  
     }
 185  
 
 186  
     public R visitTimeLiteral(TimeLiteralTree node, P p) {
 187  0
         return null;
 188  
     }
 189  
 
 190  
     public R visitTypeAny(TypeAnyTree node, P p) {
 191  0
         return null;
 192  
     }
 193  
 
 194  
     public R visitTypeClass(TypeClassTree node, P p) {
 195  6
         return scan(node.getClassName(), p);
 196  
     }
 197  
 
 198  
     public R visitTypeFunctional(TypeFunctionalTree node, P p) {
 199  0
         R r = scan(node.getReturnType(), p);
 200  0
         return scanAndReduce(node.getParameters(), p, r);
 201  
     }
 202  
 
 203  
     public R visitTypeUnknown(TypeUnknownTree node, P p) {
 204  4
         return null;
 205  
     }
 206  
 
 207  
     public R visitVariable(JavaFXVariableTree node, P p) {
 208  7
         R r = scan(node.getModifiers(), p);
 209  7
         r = scanAndReduce(node.getInitializer(), p, r);
 210  7
         r = scanAndReduce(node.getJFXType(), p, r);
 211  7
         return scanAndReduce(node.getOnReplaceTree(), p, r);
 212  
     }
 213  
 }