Correct Modifier usage, delete empty javadoc

JCTools · Nov 6, 2019 · 88ca9a5 · 88ca9a5
1 parent c209c08
commit 88ca9a5
Show file tree

Hide file tree

Showing 2 changed files with 14 additions and 29 deletions.
diff --git a/...s-build/src/main/java/org/jctools/queues/atomic/JavaParsingAtomicArrayQueueGenerator.java b/...s-build/src/main/java/org/jctools/queues/atomic/JavaParsingAtomicArrayQueueGenerator.java
@@ -5,6 +5,7 @@
 
 import com.github.javaparser.ast.CompilationUnit;
 import com.github.javaparser.ast.ImportDeclaration;
+import com.github.javaparser.ast.Modifier;
 import com.github.javaparser.ast.Modifier.Keyword;
 import com.github.javaparser.ast.body.ClassOrInterfaceDeclaration;
 import com.github.javaparser.ast.body.ConstructorDeclaration;
@@ -31,7 +32,7 @@ public final class JavaParsingAtomicArrayQueueGenerator extends JavaParsingAtomi
     public static void main(String[] args) throws Exception {
         main(JavaParsingAtomicArrayQueueGenerator.class, args);
     }
-    
+
     JavaParsingAtomicArrayQueueGenerator(String sourceFileName) {
         super(sourceFileName);
     }
@@ -125,9 +126,6 @@ void organiseImports(CompilationUnit cu) {
      * Given a variable declaration of some sort, check it's name and type and
      * if it looks like any of the key type changes between unsafe and atomic
      * queues, perform the conversion to change it's type.
-     * 
-     * @param node
-     * @param name
      */
     void processSpecialNodeTypes(NodeWithType<?, Type> node, String name) {
         Type type = node.getType();
@@ -151,8 +149,6 @@ void processSpecialNodeTypes(NodeWithType<?, Type> node, String name) {
      * Searches all extended or implemented super classes or interfaces for
      * special classes that differ with the atomics version and replaces them
      * with the appropriate class.
-     * 
-     * @param n
      */
     private void replaceParentClassesForAtomics(ClassOrInterfaceDeclaration n) {
         for (ClassOrInterfaceType parent : n.getExtendedTypes()) {
@@ -173,11 +169,6 @@ private void replaceParentClassesForAtomics(ClassOrInterfaceDeclaration n) {
      * signature with code to redirect all calls to it to the
      * <code>newMethodName</code>. Method signatures of both methods must match
      * exactly.
-     * 
-     * @param methodToPatch
-     * @param toMethodName
-     * @param returnType
-     * @param parameters
      */
     private void patchMethodAsDeprecatedRedirector(MethodDeclaration methodToPatch, String toMethodName,
             Type returnType, Parameter... parameters) {
@@ -206,15 +197,15 @@ private void patchMethodAsDeprecatedRedirector(MethodDeclaration methodToPatch,
      * the field name are processed. Clearly <code>lv<code>, <code>lp<code> and
      * <code>sv<code> are simple field accesses with only <code>so and <code>cas
      * <code> using the AtomicFieldUpdaters.
-     * 
+     *
      * @param n
      *            the AST node for the containing class
      */
     private void patchAtomicFieldUpdaterAccessorMethods(ClassOrInterfaceDeclaration n) {
         String className = n.getNameAsString();
 
         for (FieldDeclaration field : n.getFields()) {
-            if (field.getModifiers().contains(Keyword.STATIC)) {
+            if (field.getModifiers().contains(Modifier.staticModifier())) {
                 // Ignore statics
                 continue;
             }

diff --git a/...-build/src/main/java/org/jctools/queues/atomic/JavaParsingAtomicLinkedQueueGenerator.java b/...-build/src/main/java/org/jctools/queues/atomic/JavaParsingAtomicLinkedQueueGenerator.java
@@ -91,7 +91,7 @@ public void visit(ClassOrInterfaceDeclaration node, Void arg) {
     @Override
     public void visit(CastExpr n, Void arg) {
         super.visit(n, arg);
-        
+
         if (isRefArray(n.getType(), "E")) {
             n.setType(atomicRefArrayType((ArrayType) n.getType()));
         }
@@ -114,11 +114,11 @@ String translateQueueName(String originalQueueName) {
         if (originalQueueName.length() < 5) {
             return originalQueueName;
         }
-        
+
         if (originalQueueName.contains("LinkedQueue") || originalQueueName.contains("LinkedArrayQueue")) {
             return originalQueueName.replace("Linked", "LinkedAtomic");
         }
-        
+
         if (originalQueueName.contains("ArrayQueue")) {
             return originalQueueName.replace("ArrayQueue", "AtomicArrayQueue");
         }
@@ -153,11 +153,11 @@ void organiseImports(CompilationUnit cu) {
             if (name.startsWith("org.jctools.queues.CircularArrayOffsetCalculator")) {
                 continue;
             }
-            
+
             if (name.startsWith("org.jctools.queues.LinkedArrayQueueUtil")) {
                 importDeclaration.setName(name.replace("org.jctools.queues.LinkedArrayQueueUtil", "org.jctools.queues.atomic.LinkedAtomicArrayQueueUtil"));
             }
-            
+
             importDecls.add(importDeclaration);
         }
         cu.getImports().clear();
@@ -180,9 +180,6 @@ void organiseImports(CompilationUnit cu) {
      * Given a variable declaration of some sort, check it's name and type and
      * if it looks like any of the key type changes between unsafe and atomic
      * queues, perform the conversion to change it's type.
-     * 
-     * @param node
-     * @param name
      */
     void processSpecialNodeTypes(NodeWithType<?, Type> node, String name) {
         Type type = node.getType();
@@ -207,8 +204,6 @@ void processSpecialNodeTypes(NodeWithType<?, Type> node, String name) {
      * Searches all extended or implemented super classes or interfaces for
      * special classes that differ with the atomics version and replaces them
      * with the appropriate class.
-     * 
-     * @param n
      */
     private void replaceParentClassesForAtomics(ClassOrInterfaceDeclaration n) {
         replaceParentClassesForAtomics(n.getExtendedTypes());
@@ -233,15 +228,14 @@ private void replaceParentClassesForAtomics(NodeList<ClassOrInterfaceType> types
      * followed by the field name are processed. Clearly <code>lv<code>,
      * <code>lp<code> and <code>sv<code> are simple field accesses with only
      * <code>so and <code>cas <code> using the AtomicFieldUpdaters.
-     * 
-     * @param n
-     *            the AST node for the containing class
+     *
+     * @param n the AST node for the containing class
      */
     private void patchAtomicFieldUpdaterAccessorMethods(ClassOrInterfaceDeclaration n) {
         String className = n.getNameAsString();
 
         for (FieldDeclaration field : n.getFields()) {
-            if (field.getModifiers().contains(Keyword.STATIC)) {
+            if (field.getModifiers().contains(Modifier.staticModifier())) {
                 // Ignore statics
                 continue;
             }
@@ -312,7 +306,7 @@ private void patchAtomicFieldUpdaterAccessorMethods(ClassOrInterfaceDeclaration
     /**
      * Generates something like
      * <code>return P_INDEX_UPDATER.getAndSet(this, newValue)</code>
-     * 
+     *
      * @param fieldUpdaterFieldName
      * @param newValueName
      * @return
@@ -327,7 +321,7 @@ private BlockStmt fieldUpdaterGetAndSet(String fieldUpdaterFieldName, String new
     /**
      * Generates something like
      * <code>private static final AtomicReferenceFieldUpdater<MpmcAtomicArrayQueueProducerNodeField> P_NODE_UPDATER = AtomicReferenceFieldUpdater.newUpdater(MpmcAtomicArrayQueueProducerNodeField.class, "producerNode");</code>
-     * 
+     *
      * @param className
      * @param variableName
      * @return