Make ModifierAccessor an utility class

gastaldi · gastaldi · commit d36af3027d6d · 2026-01-04T20:31:02.000-03:00
diff --git a/impl/src/main/java/org/jboss/forge/roaster/model/ast/ModifierAccessor.java b/impl/src/main/java/org/jboss/forge/roaster/model/ast/ModifierAccessor.java
@@ -9,37 +9,41 @@
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
-import java.util.stream.Collectors;
 
 import org.eclipse.jdt.core.dom.ASTNode;
 import org.eclipse.jdt.core.dom.BodyDeclaration;
 import org.eclipse.jdt.core.dom.Modifier;
 import org.eclipse.jdt.core.dom.Modifier.ModifierKeyword;
 import org.eclipse.jdt.core.dom.SingleVariableDeclaration;
 
-public class ModifierAccessor
+public final class ModifierAccessor
 {
-   public boolean hasModifier(ASTNode body, final ModifierKeyword keyword)
+
+   private ModifierAccessor()
+   {
+      throw new InternalError("Utility class");
+   }
+
+   public static boolean hasModifier(ASTNode body, final ModifierKeyword keyword)
    {
-      return getModifiers(body).stream().filter(modifier -> modifier.getKeyword() == keyword).count() != 0;
+      return getModifiers(body).stream().anyMatch(modifier -> modifier.getKeyword() == keyword);
    }
 
-   private List<Modifier> getModifiers(ASTNode body)
+   private static List<Modifier> getModifiers(ASTNode body)
    {
       List<Modifier> result = new ArrayList<>();
       List<?> modifiers = getInternalModifiers(body);
       for (Object m : modifiers)
       {
-         if (m instanceof Modifier)
+         if (m instanceof Modifier mod)
          {
-            Modifier mod = (Modifier) m;
             result.add(mod);
          }
       }
       return result;
    }
 
-   public List<Modifier> clearVisibility(ASTNode body)
+   public static List<Modifier> clearVisibility(ASTNode body)
    {
       List<Modifier> modifiers = getModifiers(body);
 
@@ -56,19 +60,19 @@ public List<Modifier> clearVisibility(ASTNode body)
       return modifiers;
    }
 
-   public void addModifier(ASTNode body, ModifierKeyword keyword)
+   public static void addModifier(ASTNode body, ModifierKeyword keyword)
    {
       if (!hasModifier(body, keyword))
       {
          getInternalModifiers(body).add(body.getAST().newModifier(keyword));
       }
    }
 
-   public void removeModifier(ASTNode body, ModifierKeyword keyword)
+   public static void removeModifier(ASTNode body, ModifierKeyword keyword)
    {
       List<Modifier> toBeRemoved = getModifiers(body).stream()
                .filter(modifier -> modifier.getKeyword().equals(keyword))
-               .collect(Collectors.toList());
+               .toList();
       getInternalModifiers(body).removeAll(toBeRemoved);
    }
 
diff --git a/impl/src/main/java/org/jboss/forge/roaster/model/impl/AbstractJavaSource.java b/impl/src/main/java/org/jboss/forge/roaster/model/impl/AbstractJavaSource.java
@@ -41,7 +41,6 @@ public abstract class AbstractJavaSource<O extends JavaSource<O>> extends JavaSo
          TypeHolderSource<O>, StaticCapableSource<O>
 {
    protected final BodyDeclaration body;
-   private final ModifierAccessor modifiers = new ModifierAccessor();
 
    protected AbstractJavaSource(JavaSource<?> enclosingType, final Document document, final CompilationUnit unit,
             BodyDeclaration body)
@@ -166,19 +165,19 @@ public <NESTED_TYPE extends JavaSource<?>> NESTED_TYPE addNestedType(String decl
    @Override
    public boolean isStatic()
    {
-      return modifiers.hasModifier(getDeclaration(), ModifierKeyword.STATIC_KEYWORD);
+      return ModifierAccessor.hasModifier(getDeclaration(), ModifierKeyword.STATIC_KEYWORD);
    }
 
    @Override
    public O setStatic(boolean _static)
    {
       if (_static)
       {
-         modifiers.addModifier(getDeclaration(), ModifierKeyword.STATIC_KEYWORD);
+         ModifierAccessor.addModifier(getDeclaration(), ModifierKeyword.STATIC_KEYWORD);
       }
       else
       {
-         modifiers.removeModifier(getDeclaration(), ModifierKeyword.STATIC_KEYWORD);
+         ModifierAccessor.removeModifier(getDeclaration(), ModifierKeyword.STATIC_KEYWORD);
       }
       return (O) this;
    }
diff --git a/impl/src/main/java/org/jboss/forge/roaster/model/impl/FieldImpl.java b/impl/src/main/java/org/jboss/forge/roaster/model/impl/FieldImpl.java
@@ -39,7 +39,6 @@
 public class FieldImpl<O extends JavaSource<O>> implements FieldSource<O>
 {
    private final AnnotationAccessor<O, FieldSource<O>> annotations = new AnnotationAccessor<>();
-   private final ModifierAccessor modifiers = new ModifierAccessor();
 
    private final O parent;
    private final AST ast;
@@ -188,32 +187,32 @@ public String toString()
    @Override
    public boolean isFinal()
    {
-      return modifiers.hasModifier(field, ModifierKeyword.FINAL_KEYWORD);
+      return ModifierAccessor.hasModifier(field, ModifierKeyword.FINAL_KEYWORD);
    }
 
    @Override
    public FieldSource<O> setFinal(final boolean finl)
    {
       if (finl)
-         modifiers.addModifier(field, ModifierKeyword.FINAL_KEYWORD);
+         ModifierAccessor.addModifier(field, ModifierKeyword.FINAL_KEYWORD);
       else
-         modifiers.removeModifier(field, ModifierKeyword.FINAL_KEYWORD);
+         ModifierAccessor.removeModifier(field, ModifierKeyword.FINAL_KEYWORD);
       return this;
    }
 
    @Override
    public boolean isStatic()
    {
-      return getOrigin().isInterface() || modifiers.hasModifier(field, ModifierKeyword.STATIC_KEYWORD);
+      return getOrigin().isInterface() || ModifierAccessor.hasModifier(field, ModifierKeyword.STATIC_KEYWORD);
    }
 
    @Override
    public FieldSource<O> setStatic(final boolean statc)
    {
       if (statc)
-         modifiers.addModifier(field, ModifierKeyword.STATIC_KEYWORD);
+         ModifierAccessor.addModifier(field, ModifierKeyword.STATIC_KEYWORD);
       else
-         modifiers.removeModifier(field, ModifierKeyword.STATIC_KEYWORD);
+         ModifierAccessor.removeModifier(field, ModifierKeyword.STATIC_KEYWORD);
       return this;
    }
 
@@ -226,49 +225,49 @@ public boolean isPackagePrivate()
    @Override
    public FieldSource<O> setPackagePrivate()
    {
-      modifiers.clearVisibility(field);
+      ModifierAccessor.clearVisibility(field);
       return this;
    }
 
    @Override
    public boolean isPublic()
    {
-      return modifiers.hasModifier(field, ModifierKeyword.PUBLIC_KEYWORD);
+      return ModifierAccessor.hasModifier(field, ModifierKeyword.PUBLIC_KEYWORD);
    }
 
    @Override
    public FieldSource<O> setPublic()
    {
-      modifiers.clearVisibility(field);
-      modifiers.addModifier(field, ModifierKeyword.PUBLIC_KEYWORD);
+      ModifierAccessor.clearVisibility(field);
+      ModifierAccessor.addModifier(field, ModifierKeyword.PUBLIC_KEYWORD);
       return this;
    }
 
    @Override
    public boolean isPrivate()
    {
-      return modifiers.hasModifier(field, ModifierKeyword.PRIVATE_KEYWORD);
+      return ModifierAccessor.hasModifier(field, ModifierKeyword.PRIVATE_KEYWORD);
    }
 
    @Override
    public FieldSource<O> setPrivate()
    {
-      modifiers.clearVisibility(field);
-      modifiers.addModifier(field, ModifierKeyword.PRIVATE_KEYWORD);
+      ModifierAccessor.clearVisibility(field);
+      ModifierAccessor.addModifier(field, ModifierKeyword.PRIVATE_KEYWORD);
       return this;
    }
 
    @Override
    public boolean isProtected()
    {
-      return modifiers.hasModifier(field, ModifierKeyword.PROTECTED_KEYWORD);
+      return ModifierAccessor.hasModifier(field, ModifierKeyword.PROTECTED_KEYWORD);
    }
 
    @Override
    public FieldSource<O> setProtected()
    {
-      modifiers.clearVisibility(field);
-      modifiers.addModifier(field, ModifierKeyword.PROTECTED_KEYWORD);
+      ModifierAccessor.clearVisibility(field);
+      ModifierAccessor.addModifier(field, ModifierKeyword.PROTECTED_KEYWORD);
       return this;
    }
 
@@ -411,32 +410,32 @@ else if (!fragment.equals(other.fragment))
    @Override
    public boolean isTransient()
    {
-      return modifiers.hasModifier(field, ModifierKeyword.TRANSIENT_KEYWORD);
+      return ModifierAccessor.hasModifier(field, ModifierKeyword.TRANSIENT_KEYWORD);
    }
 
    @Override
    public FieldSource<O> setTransient(boolean value)
    {
       if (value)
-         modifiers.addModifier(field, ModifierKeyword.TRANSIENT_KEYWORD);
+         ModifierAccessor.addModifier(field, ModifierKeyword.TRANSIENT_KEYWORD);
       else
-         modifiers.removeModifier(field, ModifierKeyword.TRANSIENT_KEYWORD);
+         ModifierAccessor.removeModifier(field, ModifierKeyword.TRANSIENT_KEYWORD);
       return this;
    }
 
    @Override
    public boolean isVolatile()
    {
-      return modifiers.hasModifier(field, ModifierKeyword.VOLATILE_KEYWORD);
+      return ModifierAccessor.hasModifier(field, ModifierKeyword.VOLATILE_KEYWORD);
    }
 
    @Override
    public FieldSource<O> setVolatile(boolean value)
    {
       if (value)
-         modifiers.addModifier(field, ModifierKeyword.VOLATILE_KEYWORD);
+         ModifierAccessor.addModifier(field, ModifierKeyword.VOLATILE_KEYWORD);
       else
-         modifiers.removeModifier(field, ModifierKeyword.VOLATILE_KEYWORD);
+         ModifierAccessor.removeModifier(field, ModifierKeyword.VOLATILE_KEYWORD);
       return this;
    }
 
diff --git a/impl/src/main/java/org/jboss/forge/roaster/model/impl/JavaClassImpl.java b/impl/src/main/java/org/jboss/forge/roaster/model/impl/JavaClassImpl.java
@@ -31,7 +31,6 @@
  */
 public class JavaClassImpl extends AbstractGenericCapableJavaSource<JavaClassSource> implements JavaClassSource
 {
-   private final ModifierAccessor modifiers = new ModifierAccessor();
 
    public JavaClassImpl(JavaSource<?> enclosingType, final Document document, final CompilationUnit unit,
             BodyDeclaration body)
@@ -59,36 +58,36 @@ protected JavaClassSource updateTypeNames(final String newName)
    @Override
    public boolean isAbstract()
    {
-      return modifiers.hasModifier(getDeclaration(), ModifierKeyword.ABSTRACT_KEYWORD);
+      return ModifierAccessor.hasModifier(getDeclaration(), ModifierKeyword.ABSTRACT_KEYWORD);
    }
 
    @Override
    public JavaClassSource setAbstract(final boolean abstrct)
    {
       if (abstrct)
       {
-         modifiers.addModifier(getDeclaration(), ModifierKeyword.ABSTRACT_KEYWORD);
+         ModifierAccessor.addModifier(getDeclaration(), ModifierKeyword.ABSTRACT_KEYWORD);
       }
       else
       {
-         modifiers.removeModifier(getDeclaration(), ModifierKeyword.ABSTRACT_KEYWORD);
+         ModifierAccessor.removeModifier(getDeclaration(), ModifierKeyword.ABSTRACT_KEYWORD);
       }
       return this;
    }
 
    @Override
    public boolean isFinal()
    {
-      return modifiers.hasModifier(getDeclaration(), ModifierKeyword.FINAL_KEYWORD);
+      return ModifierAccessor.hasModifier(getDeclaration(), ModifierKeyword.FINAL_KEYWORD);
    }
 
    @Override
    public JavaClassSource setFinal(boolean finl)
    {
       if (finl)
-         modifiers.addModifier(getDeclaration(), ModifierKeyword.FINAL_KEYWORD);
+         ModifierAccessor.addModifier(getDeclaration(), ModifierKeyword.FINAL_KEYWORD);
       else
-         modifiers.removeModifier(getDeclaration(), ModifierKeyword.FINAL_KEYWORD);
+         ModifierAccessor.removeModifier(getDeclaration(), ModifierKeyword.FINAL_KEYWORD);
       return this;
    }
 
diff --git a/impl/src/main/java/org/jboss/forge/roaster/model/impl/JavaSourceImpl.java b/impl/src/main/java/org/jboss/forge/roaster/model/impl/JavaSourceImpl.java
@@ -53,7 +53,6 @@
 public abstract class JavaSourceImpl<O extends JavaSource<O>> implements JavaSource<O>
 {
    private static List<WildcardImportResolver> resolvers;
-   private final ModifierAccessor modifiers = new ModifierAccessor();
    private final AnnotationAccessor<O, O> annotations = new AnnotationAccessor<>();
 
    protected final Document document;
@@ -681,52 +680,52 @@ public String toUnformattedString()
    @Override
    public O setPackagePrivate()
    {
-      modifiers.clearVisibility(getDeclaration());
+      ModifierAccessor.clearVisibility(getDeclaration());
       return (O) this;
    }
 
    @Override
    public boolean isPublic()
    {
-      return modifiers.hasModifier(getDeclaration(), ModifierKeyword.PUBLIC_KEYWORD);
+      return ModifierAccessor.hasModifier(getDeclaration(), ModifierKeyword.PUBLIC_KEYWORD);
    }
 
    @SuppressWarnings("unchecked")
    @Override
    public O setPublic()
    {
-      modifiers.clearVisibility(getDeclaration());
-      modifiers.addModifier(getDeclaration(), ModifierKeyword.PUBLIC_KEYWORD);
+      ModifierAccessor.clearVisibility(getDeclaration());
+      ModifierAccessor.addModifier(getDeclaration(), ModifierKeyword.PUBLIC_KEYWORD);
       return (O) this;
    }
 
    @Override
    public boolean isPrivate()
    {
-      return modifiers.hasModifier(getDeclaration(), ModifierKeyword.PRIVATE_KEYWORD);
+      return ModifierAccessor.hasModifier(getDeclaration(), ModifierKeyword.PRIVATE_KEYWORD);
    }
 
    @SuppressWarnings("unchecked")
    @Override
    public O setPrivate()
    {
-      modifiers.clearVisibility(getDeclaration());
-      modifiers.addModifier(getDeclaration(), ModifierKeyword.PRIVATE_KEYWORD);
+      ModifierAccessor.clearVisibility(getDeclaration());
+      ModifierAccessor.addModifier(getDeclaration(), ModifierKeyword.PRIVATE_KEYWORD);
       return (O) this;
    }
 
    @Override
    public boolean isProtected()
    {
-      return modifiers.hasModifier(getDeclaration(), ModifierKeyword.PROTECTED_KEYWORD);
+      return ModifierAccessor.hasModifier(getDeclaration(), ModifierKeyword.PROTECTED_KEYWORD);
    }
 
    @SuppressWarnings("unchecked")
    @Override
    public O setProtected()
    {
-      modifiers.clearVisibility(getDeclaration());
-      modifiers.addModifier(getDeclaration(), ModifierKeyword.PROTECTED_KEYWORD);
+      ModifierAccessor.clearVisibility(getDeclaration());
+      ModifierAccessor.addModifier(getDeclaration(), ModifierKeyword.PROTECTED_KEYWORD);
       return (O) this;
    }
 
diff --git a/impl/src/main/java/org/jboss/forge/roaster/model/impl/MethodImpl.java b/impl/src/main/java/org/jboss/forge/roaster/model/impl/MethodImpl.java
diff --git a/impl/src/main/java/org/jboss/forge/roaster/model/impl/ParameterImpl.java b/impl/src/main/java/org/jboss/forge/roaster/model/impl/ParameterImpl.java

Original file line number	Diff line number	Diff line change
`@@ -9,37 +9,41 @@`
`9`	`9`	`import java.util.ArrayList;`
`10`	`10`	`import java.util.Collections;`
`11`	`11`	`import java.util.List;`
`12`		`-import java.util.stream.Collectors;`
`13`	`12`
`14`	`13`	`import org.eclipse.jdt.core.dom.ASTNode;`
`15`	`14`	`import org.eclipse.jdt.core.dom.BodyDeclaration;`
`16`	`15`	`import org.eclipse.jdt.core.dom.Modifier;`
`17`	`16`	`import org.eclipse.jdt.core.dom.Modifier.ModifierKeyword;`
`18`	`17`	`import org.eclipse.jdt.core.dom.SingleVariableDeclaration;`
`19`	`18`
`20`		`-public class ModifierAccessor`
	`19`	`+public final class ModifierAccessor`
`21`	`20`	`{`
`22`		`- public boolean hasModifier(ASTNode body, final ModifierKeyword keyword)`
	`21`	`+`
	`22`	`+ private ModifierAccessor()`
	`23`	`+ {`
	`24`	`+ throw new InternalError("Utility class");`
	`25`	`+ }`
	`26`	`+`
	`27`	`+ public static boolean hasModifier(ASTNode body, final ModifierKeyword keyword)`
`23`	`28`	`{`
`24`		`- return getModifiers(body).stream().filter(modifier -> modifier.getKeyword() == keyword).count() != 0;`
	`29`	`+ return getModifiers(body).stream().anyMatch(modifier -> modifier.getKeyword() == keyword);`
`25`	`30`	`}`
`26`	`31`
`27`		`- private List<Modifier> getModifiers(ASTNode body)`
	`32`	`+ private static List<Modifier> getModifiers(ASTNode body)`
`28`	`33`	`{`
`29`	`34`	`List<Modifier> result = new ArrayList<>();`
`30`	`35`	`List<?> modifiers = getInternalModifiers(body);`
`31`	`36`	`for (Object m : modifiers)`
`32`	`37`	`{`
`33`		`- if (m instanceof Modifier)`
	`38`	`+ if (m instanceof Modifier mod)`
`34`	`39`	`{`
`35`		`- Modifier mod = (Modifier) m;`
`36`	`40`	`result.add(mod);`
`37`	`41`	`}`
`38`	`42`	`}`
`39`	`43`	`return result;`
`40`	`44`	`}`
`41`	`45`
`42`		`- public List<Modifier> clearVisibility(ASTNode body)`
	`46`	`+ public static List<Modifier> clearVisibility(ASTNode body)`
`43`	`47`	`{`
`44`	`48`	`List<Modifier> modifiers = getModifiers(body);`
`45`	`49`
`@@ -56,19 +60,19 @@ public List<Modifier> clearVisibility(ASTNode body)`
`56`	`60`	`return modifiers;`
`57`	`61`	`}`
`58`	`62`
`59`		`- public void addModifier(ASTNode body, ModifierKeyword keyword)`
	`63`	`+ public static void addModifier(ASTNode body, ModifierKeyword keyword)`
`60`	`64`	`{`
`61`	`65`	`if (!hasModifier(body, keyword))`
`62`	`66`	`{`
`63`	`67`	`getInternalModifiers(body).add(body.getAST().newModifier(keyword));`
`64`	`68`	`}`
`65`	`69`	`}`
`66`	`70`
`67`		`- public void removeModifier(ASTNode body, ModifierKeyword keyword)`
	`71`	`+ public static void removeModifier(ASTNode body, ModifierKeyword keyword)`
`68`	`72`	`{`
`69`	`73`	`List<Modifier> toBeRemoved = getModifiers(body).stream()`
`70`	`74`	`.filter(modifier -> modifier.getKeyword().equals(keyword))`
`71`		`- .collect(Collectors.toList());`
	`75`	`+ .toList();`
`72`	`76`	`getInternalModifiers(body).removeAll(toBeRemoved);`
`73`	`77`	`}`
`74`	`78`
Original file line number	Diff line number	Diff line change
`@@ -41,7 +41,6 @@ public abstract class AbstractJavaSource<O extends JavaSource<O>> extends JavaSo`
`41`	`41`	`TypeHolderSource<O>, StaticCapableSource<O>`
`42`	`42`	`{`
`43`	`43`	`protected final BodyDeclaration body;`
`44`		`- private final ModifierAccessor modifiers = new ModifierAccessor();`
`45`	`44`
`46`	`45`	`protected AbstractJavaSource(JavaSource<?> enclosingType, final Document document, final CompilationUnit unit,`
`47`	`46`	`BodyDeclaration body)`
`@@ -166,19 +165,19 @@ public <NESTED_TYPE extends JavaSource<?>> NESTED_TYPE addNestedType(String decl`
`166`	`165`	`@Override`
`167`	`166`	`public boolean isStatic()`
`168`	`167`	`{`
`169`		`- return modifiers.hasModifier(getDeclaration(), ModifierKeyword.STATIC_KEYWORD);`
	`168`	`+ return ModifierAccessor.hasModifier(getDeclaration(), ModifierKeyword.STATIC_KEYWORD);`
`170`	`169`	`}`
`171`	`170`
`172`	`171`	`@Override`
`173`	`172`	`public O setStatic(boolean _static)`
`174`	`173`	`{`
`175`	`174`	`if (_static)`
`176`	`175`	`{`
`177`		`- modifiers.addModifier(getDeclaration(), ModifierKeyword.STATIC_KEYWORD);`
	`176`	`+ ModifierAccessor.addModifier(getDeclaration(), ModifierKeyword.STATIC_KEYWORD);`
`178`	`177`	`}`
`179`	`178`	`else`
`180`	`179`	`{`
`181`		`- modifiers.removeModifier(getDeclaration(), ModifierKeyword.STATIC_KEYWORD);`
	`180`	`+ ModifierAccessor.removeModifier(getDeclaration(), ModifierKeyword.STATIC_KEYWORD);`
`182`	`181`	`}`
`183`	`182`	`return (O) this;`
`184`	`183`	`}`
Original file line number	Diff line number	Diff line change
`@@ -39,7 +39,6 @@`
`39`	`39`	`public class FieldImpl<O extends JavaSource<O>> implements FieldSource<O>`
`40`	`40`	`{`
`41`	`41`	`private final AnnotationAccessor<O, FieldSource<O>> annotations = new AnnotationAccessor<>();`
`42`		`- private final ModifierAccessor modifiers = new ModifierAccessor();`
`43`	`42`
`44`	`43`	`private final O parent;`
`45`	`44`	`private final AST ast;`
`@@ -188,32 +187,32 @@ public String toString()`
`188`	`187`	`@Override`
`189`	`188`	`public boolean isFinal()`
`190`	`189`	`{`
`191`		`- return modifiers.hasModifier(field, ModifierKeyword.FINAL_KEYWORD);`
	`190`	`+ return ModifierAccessor.hasModifier(field, ModifierKeyword.FINAL_KEYWORD);`
`192`	`191`	`}`
`193`	`192`
`194`	`193`	`@Override`
`195`	`194`	`public FieldSource<O> setFinal(final boolean finl)`
`196`	`195`	`{`
`197`	`196`	`if (finl)`
`198`		`- modifiers.addModifier(field, ModifierKeyword.FINAL_KEYWORD);`
	`197`	`+ ModifierAccessor.addModifier(field, ModifierKeyword.FINAL_KEYWORD);`
`199`	`198`	`else`
`200`		`- modifiers.removeModifier(field, ModifierKeyword.FINAL_KEYWORD);`
	`199`	`+ ModifierAccessor.removeModifier(field, ModifierKeyword.FINAL_KEYWORD);`
`201`	`200`	`return this;`
`202`	`201`	`}`
`203`	`202`
`204`	`203`	`@Override`
`205`	`204`	`public boolean isStatic()`
`206`	`205`	`{`
`207`		`- return getOrigin().isInterface() \|\| modifiers.hasModifier(field, ModifierKeyword.STATIC_KEYWORD);`
	`206`	`+ return getOrigin().isInterface() \|\| ModifierAccessor.hasModifier(field, ModifierKeyword.STATIC_KEYWORD);`
`208`	`207`	`}`
`209`	`208`
`210`	`209`	`@Override`
`211`	`210`	`public FieldSource<O> setStatic(final boolean statc)`
`212`	`211`	`{`
`213`	`212`	`if (statc)`
`214`		`- modifiers.addModifier(field, ModifierKeyword.STATIC_KEYWORD);`
	`213`	`+ ModifierAccessor.addModifier(field, ModifierKeyword.STATIC_KEYWORD);`
`215`	`214`	`else`
`216`		`- modifiers.removeModifier(field, ModifierKeyword.STATIC_KEYWORD);`
	`215`	`+ ModifierAccessor.removeModifier(field, ModifierKeyword.STATIC_KEYWORD);`
`217`	`216`	`return this;`
`218`	`217`	`}`
`219`	`218`
`@@ -226,49 +225,49 @@ public boolean isPackagePrivate()`
`226`	`225`	`@Override`
`227`	`226`	`public FieldSource<O> setPackagePrivate()`
`228`	`227`	`{`
`229`		`- modifiers.clearVisibility(field);`
	`228`	`+ ModifierAccessor.clearVisibility(field);`
`230`	`229`	`return this;`
`231`	`230`	`}`
`232`	`231`
`233`	`232`	`@Override`
`234`	`233`	`public boolean isPublic()`
`235`	`234`	`{`
`236`		`- return modifiers.hasModifier(field, ModifierKeyword.PUBLIC_KEYWORD);`
	`235`	`+ return ModifierAccessor.hasModifier(field, ModifierKeyword.PUBLIC_KEYWORD);`
`237`	`236`	`}`
`238`	`237`
`239`	`238`	`@Override`
`240`	`239`	`public FieldSource<O> setPublic()`
`241`	`240`	`{`
`242`		`- modifiers.clearVisibility(field);`
`243`		`- modifiers.addModifier(field, ModifierKeyword.PUBLIC_KEYWORD);`
	`241`	`+ ModifierAccessor.clearVisibility(field);`
	`242`	`+ ModifierAccessor.addModifier(field, ModifierKeyword.PUBLIC_KEYWORD);`
`244`	`243`	`return this;`
`245`	`244`	`}`
`246`	`245`
`247`	`246`	`@Override`
`248`	`247`	`public boolean isPrivate()`
`249`	`248`	`{`
`250`		`- return modifiers.hasModifier(field, ModifierKeyword.PRIVATE_KEYWORD);`
	`249`	`+ return ModifierAccessor.hasModifier(field, ModifierKeyword.PRIVATE_KEYWORD);`
`251`	`250`	`}`
`252`	`251`
`253`	`252`	`@Override`
`254`	`253`	`public FieldSource<O> setPrivate()`
`255`	`254`	`{`
`256`		`- modifiers.clearVisibility(field);`
`257`		`- modifiers.addModifier(field, ModifierKeyword.PRIVATE_KEYWORD);`
	`255`	`+ ModifierAccessor.clearVisibility(field);`
	`256`	`+ ModifierAccessor.addModifier(field, ModifierKeyword.PRIVATE_KEYWORD);`
`258`	`257`	`return this;`
`259`	`258`	`}`
`260`	`259`
`261`	`260`	`@Override`
`262`	`261`	`public boolean isProtected()`
`263`	`262`	`{`
`264`		`- return modifiers.hasModifier(field, ModifierKeyword.PROTECTED_KEYWORD);`
	`263`	`+ return ModifierAccessor.hasModifier(field, ModifierKeyword.PROTECTED_KEYWORD);`
`265`	`264`	`}`
`266`	`265`
`267`	`266`	`@Override`
`268`	`267`	`public FieldSource<O> setProtected()`
`269`	`268`	`{`
`270`		`- modifiers.clearVisibility(field);`
`271`		`- modifiers.addModifier(field, ModifierKeyword.PROTECTED_KEYWORD);`
	`269`	`+ ModifierAccessor.clearVisibility(field);`
	`270`	`+ ModifierAccessor.addModifier(field, ModifierKeyword.PROTECTED_KEYWORD);`
`272`	`271`	`return this;`
`273`	`272`	`}`
`274`	`273`
`@@ -411,32 +410,32 @@ else if (!fragment.equals(other.fragment))`
`411`	`410`	`@Override`
`412`	`411`	`public boolean isTransient()`
`413`	`412`	`{`
`414`		`- return modifiers.hasModifier(field, ModifierKeyword.TRANSIENT_KEYWORD);`
	`413`	`+ return ModifierAccessor.hasModifier(field, ModifierKeyword.TRANSIENT_KEYWORD);`
`415`	`414`	`}`
`416`	`415`
`417`	`416`	`@Override`
`418`	`417`	`public FieldSource<O> setTransient(boolean value)`
`419`	`418`	`{`
`420`	`419`	`if (value)`
`421`		`- modifiers.addModifier(field, ModifierKeyword.TRANSIENT_KEYWORD);`
	`420`	`+ ModifierAccessor.addModifier(field, ModifierKeyword.TRANSIENT_KEYWORD);`
`422`	`421`	`else`
`423`		`- modifiers.removeModifier(field, ModifierKeyword.TRANSIENT_KEYWORD);`
	`422`	`+ ModifierAccessor.removeModifier(field, ModifierKeyword.TRANSIENT_KEYWORD);`
`424`	`423`	`return this;`
`425`	`424`	`}`
`426`	`425`
`427`	`426`	`@Override`
`428`	`427`	`public boolean isVolatile()`
`429`	`428`	`{`
`430`		`- return modifiers.hasModifier(field, ModifierKeyword.VOLATILE_KEYWORD);`
	`429`	`+ return ModifierAccessor.hasModifier(field, ModifierKeyword.VOLATILE_KEYWORD);`
`431`	`430`	`}`
`432`	`431`
`433`	`432`	`@Override`
`434`	`433`	`public FieldSource<O> setVolatile(boolean value)`
`435`	`434`	`{`
`436`	`435`	`if (value)`
`437`		`- modifiers.addModifier(field, ModifierKeyword.VOLATILE_KEYWORD);`
	`436`	`+ ModifierAccessor.addModifier(field, ModifierKeyword.VOLATILE_KEYWORD);`
`438`	`437`	`else`
`439`		`- modifiers.removeModifier(field, ModifierKeyword.VOLATILE_KEYWORD);`
	`438`	`+ ModifierAccessor.removeModifier(field, ModifierKeyword.VOLATILE_KEYWORD);`
`440`	`439`	`return this;`
`441`	`440`	`}`
`442`	`441`
Original file line number	Diff line number	Diff line change
`@@ -31,7 +31,6 @@`
`31`	`31`	`*/`
`32`	`32`	`public class JavaClassImpl extends AbstractGenericCapableJavaSource<JavaClassSource> implements JavaClassSource`
`33`	`33`	`{`
`34`		`- private final ModifierAccessor modifiers = new ModifierAccessor();`
`35`	`34`
`36`	`35`	`public JavaClassImpl(JavaSource<?> enclosingType, final Document document, final CompilationUnit unit,`
`37`	`36`	`BodyDeclaration body)`
`@@ -59,36 +58,36 @@ protected JavaClassSource updateTypeNames(final String newName)`
`59`	`58`	`@Override`
`60`	`59`	`public boolean isAbstract()`
`61`	`60`	`{`
`62`		`- return modifiers.hasModifier(getDeclaration(), ModifierKeyword.ABSTRACT_KEYWORD);`
	`61`	`+ return ModifierAccessor.hasModifier(getDeclaration(), ModifierKeyword.ABSTRACT_KEYWORD);`
`63`	`62`	`}`
`64`	`63`
`65`	`64`	`@Override`
`66`	`65`	`public JavaClassSource setAbstract(final boolean abstrct)`
`67`	`66`	`{`
`68`	`67`	`if (abstrct)`
`69`	`68`	`{`
`70`		`- modifiers.addModifier(getDeclaration(), ModifierKeyword.ABSTRACT_KEYWORD);`
	`69`	`+ ModifierAccessor.addModifier(getDeclaration(), ModifierKeyword.ABSTRACT_KEYWORD);`
`71`	`70`	`}`
`72`	`71`	`else`
`73`	`72`	`{`
`74`		`- modifiers.removeModifier(getDeclaration(), ModifierKeyword.ABSTRACT_KEYWORD);`
	`73`	`+ ModifierAccessor.removeModifier(getDeclaration(), ModifierKeyword.ABSTRACT_KEYWORD);`
`75`	`74`	`}`
`76`	`75`	`return this;`
`77`	`76`	`}`
`78`	`77`
`79`	`78`	`@Override`
`80`	`79`	`public boolean isFinal()`
`81`	`80`	`{`
`82`		`- return modifiers.hasModifier(getDeclaration(), ModifierKeyword.FINAL_KEYWORD);`
	`81`	`+ return ModifierAccessor.hasModifier(getDeclaration(), ModifierKeyword.FINAL_KEYWORD);`
`83`	`82`	`}`
`84`	`83`
`85`	`84`	`@Override`
`86`	`85`	`public JavaClassSource setFinal(boolean finl)`
`87`	`86`	`{`
`88`	`87`	`if (finl)`
`89`		`- modifiers.addModifier(getDeclaration(), ModifierKeyword.FINAL_KEYWORD);`
	`88`	`+ ModifierAccessor.addModifier(getDeclaration(), ModifierKeyword.FINAL_KEYWORD);`
`90`	`89`	`else`
`91`		`- modifiers.removeModifier(getDeclaration(), ModifierKeyword.FINAL_KEYWORD);`
	`90`	`+ ModifierAccessor.removeModifier(getDeclaration(), ModifierKeyword.FINAL_KEYWORD);`
`92`	`91`	`return this;`
`93`	`92`	`}`
`94`	`93`
Original file line number	Diff line number	Diff line change
`@@ -53,7 +53,6 @@`
`53`	`53`	`public abstract class JavaSourceImpl<O extends JavaSource<O>> implements JavaSource<O>`
`54`	`54`	`{`
`55`	`55`	`private static List<WildcardImportResolver> resolvers;`
`56`		`- private final ModifierAccessor modifiers = new ModifierAccessor();`
`57`	`56`	`private final AnnotationAccessor<O, O> annotations = new AnnotationAccessor<>();`
`58`	`57`
`59`	`58`	`protected final Document document;`
`@@ -681,52 +680,52 @@ public String toUnformattedString()`
`681`	`680`	`@Override`
`682`	`681`	`public O setPackagePrivate()`
`683`	`682`	`{`
`684`		`- modifiers.clearVisibility(getDeclaration());`
	`683`	`+ ModifierAccessor.clearVisibility(getDeclaration());`
`685`	`684`	`return (O) this;`
`686`	`685`	`}`
`687`	`686`
`688`	`687`	`@Override`
`689`	`688`	`public boolean isPublic()`
`690`	`689`	`{`
`691`		`- return modifiers.hasModifier(getDeclaration(), ModifierKeyword.PUBLIC_KEYWORD);`
	`690`	`+ return ModifierAccessor.hasModifier(getDeclaration(), ModifierKeyword.PUBLIC_KEYWORD);`
`692`	`691`	`}`
`693`	`692`
`694`	`693`	`@SuppressWarnings("unchecked")`
`695`	`694`	`@Override`
`696`	`695`	`public O setPublic()`
`697`	`696`	`{`
`698`		`- modifiers.clearVisibility(getDeclaration());`
`699`		`- modifiers.addModifier(getDeclaration(), ModifierKeyword.PUBLIC_KEYWORD);`
	`697`	`+ ModifierAccessor.clearVisibility(getDeclaration());`
	`698`	`+ ModifierAccessor.addModifier(getDeclaration(), ModifierKeyword.PUBLIC_KEYWORD);`
`700`	`699`	`return (O) this;`
`701`	`700`	`}`
`702`	`701`
`703`	`702`	`@Override`
`704`	`703`	`public boolean isPrivate()`
`705`	`704`	`{`
`706`		`- return modifiers.hasModifier(getDeclaration(), ModifierKeyword.PRIVATE_KEYWORD);`
	`705`	`+ return ModifierAccessor.hasModifier(getDeclaration(), ModifierKeyword.PRIVATE_KEYWORD);`
`707`	`706`	`}`
`708`	`707`
`709`	`708`	`@SuppressWarnings("unchecked")`
`710`	`709`	`@Override`
`711`	`710`	`public O setPrivate()`
`712`	`711`	`{`
`713`		`- modifiers.clearVisibility(getDeclaration());`
`714`		`- modifiers.addModifier(getDeclaration(), ModifierKeyword.PRIVATE_KEYWORD);`
	`712`	`+ ModifierAccessor.clearVisibility(getDeclaration());`
	`713`	`+ ModifierAccessor.addModifier(getDeclaration(), ModifierKeyword.PRIVATE_KEYWORD);`
`715`	`714`	`return (O) this;`
`716`	`715`	`}`
`717`	`716`
`718`	`717`	`@Override`
`719`	`718`	`public boolean isProtected()`
`720`	`719`	`{`
`721`		`- return modifiers.hasModifier(getDeclaration(), ModifierKeyword.PROTECTED_KEYWORD);`
	`720`	`+ return ModifierAccessor.hasModifier(getDeclaration(), ModifierKeyword.PROTECTED_KEYWORD);`
`722`	`721`	`}`
`723`	`722`
`724`	`723`	`@SuppressWarnings("unchecked")`
`725`	`724`	`@Override`
`726`	`725`	`public O setProtected()`
`727`	`726`	`{`
`728`		`- modifiers.clearVisibility(getDeclaration());`
`729`		`- modifiers.addModifier(getDeclaration(), ModifierKeyword.PROTECTED_KEYWORD);`
	`727`	`+ ModifierAccessor.clearVisibility(getDeclaration());`
	`728`	`+ ModifierAccessor.addModifier(getDeclaration(), ModifierKeyword.PROTECTED_KEYWORD);`
`730`	`729`	`return (O) this;`
`731`	`730`	`}`
`732`	`731`