1 files changed, 143 insertions, 0 deletions
diff --git a/javaparser-symbol-solver-testing/src/test/test_sourcecode/javaparser_src/proper_source/com/github/javaparser/PositionUtils.java b/javaparser-symbol-solver-testing/src/test/test_sourcecode/javaparser_src/proper_source/com/github/javaparser/PositionUtils.java
new file mode 100644
index 000000000..41df81710
--- /dev/null
+++ b/javaparser-symbol-solver-testing/src/test/test_sourcecode/javaparser_src/proper_source/com/github/javaparser/PositionUtils.java
@@ -0,0 +1,143 @@
+/*
+ * Copyright (C) 2007-2010 Júlio Vilmar Gesser.
+ * Copyright (C) 2011, 2013-2015 The JavaParser Team.
+ *
+ * This file is part of JavaParser.
+ * 
+ * JavaParser can be used either under the terms of
+ * a) the GNU Lesser General Public License as published by
+ *     the Free Software Foundation, either version 3 of the License, or
+ *     (at your option) any later version.
+ * b) the terms of the Apache License 
+ *
+ * You should have received a copy of both licenses in LICENCE.LGPL and
+ * LICENCE.APACHE. Please refer to those files for details.
+ *
+ * JavaParser is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ */
+ 
+package com.github.javaparser;
+
+import com.github.javaparser.ast.Node;
+import com.github.javaparser.ast.body.AnnotableNode;
+import com.github.javaparser.ast.body.ClassOrInterfaceDeclaration;
+import com.github.javaparser.ast.body.FieldDeclaration;
+import com.github.javaparser.ast.body.MethodDeclaration;
+import com.github.javaparser.ast.expr.AnnotationExpr;
+
+import java.lang.Override;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.LinkedList;
+import java.util.List;
+
+import static java.lang.Integer.signum;
+
+public final class PositionUtils {
+
+    private PositionUtils() {
+        // prevent instantiation
+    }
+
+    public static <T extends Node> void sortByBeginPosition(List<T> nodes){
+        sortByBeginPosition(nodes, false);
+    }
+
+    public static <T extends Node> void sortByBeginPosition(List<T> nodes, final boolean ignoringAnnotations){
+        Collections.sort(nodes, new Comparator<Node>() {
+            @Override
+            public int compare(Node o1, Node o2) {
+                return PositionUtils.compare(o1, o2, ignoringAnnotations);
+            }
+        });
+    }
+
+    public static boolean areInOrder(Node a, Node b){
+        return areInOrder(a, b, false);
+    }
+
+    public static boolean areInOrder(Node a, Node b, boolean ignoringAnnotations){
+        return compare(a, b, ignoringAnnotations) <= 0;
+    }
+
+    private static int compare(Node a, Node b, boolean ignoringAnnotations) {
+        if (ignoringAnnotations) {
+            int signLine = signum(beginLineWithoutConsideringAnnotation(a) - beginLineWithoutConsideringAnnotation(b));
+            if (signLine == 0) {
+                return signum(beginColumnWithoutConsideringAnnotation(a) - beginColumnWithoutConsideringAnnotation(b));
+            } else {
+                return signLine;
+            }
+        }
+
+        int signLine = signum( a.getBeginLine() - b.getBeginLine() );
+        if (signLine == 0) {
+            return signum(a.getBeginColumn() - b.getBeginColumn());
+        } else {
+            return signLine;
+        }
+    }
+
+    public static AnnotationExpr getLastAnnotation(Node node) {
+        if (node instanceof AnnotableNode){
+            List<AnnotationExpr> annotations = new LinkedList<AnnotationExpr>();
+            annotations.addAll(((AnnotableNode) node).getAnnotations());
+            if (annotations.size()==0){
+                return null;
+            }
+            sortByBeginPosition(annotations);
+            return annotations.get(annotations.size()-1);
+        } else {
+            return null;
+        }
+    }
+
+    private static int beginLineWithoutConsideringAnnotation(Node node) {
+        return beginNodeWithoutConsideringAnnotations(node).getBeginLine();
+    }
+
+
+    private static int beginColumnWithoutConsideringAnnotation(Node node) {
+        return beginNodeWithoutConsideringAnnotations(node).getBeginColumn();
+    }
+
+    private static Node beginNodeWithoutConsideringAnnotations(Node node) {
+        if (node instanceof MethodDeclaration) {
+            MethodDeclaration casted = (MethodDeclaration) node;
+            return casted.getType();
+        } else if (node instanceof FieldDeclaration) {
+            FieldDeclaration casted = (FieldDeclaration) node;
+            return casted.getType();
+        } else if (node instanceof ClassOrInterfaceDeclaration) {
+            ClassOrInterfaceDeclaration casted = (ClassOrInterfaceDeclaration) node;
+            return casted.getNameExpr();
+        }  else {
+            return node;
+        }
+    }
+
+    public static boolean nodeContains(Node container, Node contained, boolean ignoringAnnotations){
+        if (!ignoringAnnotations || PositionUtils.getLastAnnotation(container)==null){
+            return container.contains(contained);
+        }
+        if (!container.contains(contained)){
+            return false;
+        }
+        // if the node is contained, but it comes immediately after the annotations,
+        // let's not consider it contained
+        if (container instanceof AnnotableNode){
+            int bl = beginLineWithoutConsideringAnnotation(container);
+            int bc = beginColumnWithoutConsideringAnnotation(container);
+            if (bl>contained.getBeginLine()) return false;
+            if (bl==contained.getBeginLine() && bc>contained.getBeginColumn()) return false;
+            if (container.getEndLine()<contained.getEndLine()) return false;
+            if (container.getEndLine()==contained.getEndLine() && container.getEndColumn()<contained.getEndColumn()) return false;
+            return true;
+        }
+        return true;
+    }
+
+}