View Javadoc
1   ///////////////////////////////////////////////////////////////////////////////////////////////
2   // checkstyle: Checks Java source code and other text files for adherence to a set of rules.
3   // Copyright (C) 2001-2025 the original author or authors.
4   //
5   // This library is free software; you can redistribute it and/or
6   // modify it under the terms of the GNU Lesser General Public
7   // License as published by the Free Software Foundation; either
8   // version 2.1 of the License, or (at your option) any later version.
9   //
10  // This library is distributed in the hope that it will be useful,
11  // but WITHOUT ANY WARRANTY; without even the implied warranty of
12  // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  // Lesser General Public License for more details.
14  //
15  // You should have received a copy of the GNU Lesser General Public
16  // License along with this library; if not, write to the Free Software
17  // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18  ///////////////////////////////////////////////////////////////////////////////////////////////
19  
20  package com.puppycrawl.tools.checkstyle.checks.naming;
21  
22  import com.puppycrawl.tools.checkstyle.api.DetailAST;
23  import com.puppycrawl.tools.checkstyle.api.TokenTypes;
24  import com.puppycrawl.tools.checkstyle.utils.ScopeUtil;
25  
26  /**
27   * Abstract class for checking a class member (field/method)'s name conforms to
28   * a specified pattern.
29   *
30   * <p>
31   * This class extends {@link AbstractNameCheck} with support for access level
32   * restrictions. This allows the check to be configured to be applied to one of
33   * the four Java access levels: {@code public}, {@code protected},
34   * {@code "package"}, and {@code private}.
35   * </p>
36   *
37   * <p>Level is configured using the following properties:
38   * <ol>
39   * <li>applyToPublic, default true;</li>
40   * <li>applyToProtected, default true;</li>
41   * <li>applyToPackage, default true;</li>
42   * <li>applyToPrivate, default true;</li>
43   * </ol>
44   *
45   */
46  public abstract class AbstractAccessControlNameCheck
47      extends AbstractNameCheck {
48  
49      /** If true, applies the check be public members. */
50      private boolean applyToPublic = true;
51  
52      /** If true, applies the check be protected members. */
53      private boolean applyToProtected = true;
54  
55      /** If true, applies the check be "package" members. */
56      private boolean applyToPackage = true;
57  
58      /** If true, applies the check be private members. */
59      private boolean applyToPrivate = true;
60  
61      /**
62       * Creates a new {@code AbstractAccessControlNameCheck} instance.
63       *
64       * @param format
65       *                format to check with
66       */
67      protected AbstractAccessControlNameCheck(String format) {
68          super(format);
69      }
70  
71      @Override
72      protected boolean mustCheckName(DetailAST ast) {
73          return shouldCheckInScope(ast.findFirstToken(TokenTypes.MODIFIERS));
74      }
75  
76      /**
77       * Should we check member with given modifiers.
78       *
79       * @param modifiers
80       *                modifiers of member to check.
81       * @return true if we should check such member.
82       */
83      protected boolean shouldCheckInScope(DetailAST modifiers) {
84          final boolean isProtected = modifiers
85                  .findFirstToken(TokenTypes.LITERAL_PROTECTED) != null;
86          final boolean isPrivate = modifiers
87                  .findFirstToken(TokenTypes.LITERAL_PRIVATE) != null;
88          final boolean isPublic = isPublic(modifiers);
89  
90          final boolean isPackage = !(isPublic || isProtected || isPrivate);
91  
92          return applyToPublic && isPublic
93                  || applyToProtected && isProtected
94                  || applyToPackage && isPackage
95                  || applyToPrivate && isPrivate;
96      }
97  
98      /**
99       * Checks if given modifiers has public access.
100      * There are 2 cases - it is either has explicit modifier, or it is
101      * in annotation or interface.
102      *
103      * @param modifiers - modifiers to check
104      * @return true if public
105      */
106     private static boolean isPublic(DetailAST modifiers) {
107         return modifiers.findFirstToken(TokenTypes.LITERAL_PUBLIC) != null
108                 || ScopeUtil.isInAnnotationBlock(modifiers)
109                 || ScopeUtil.isInInterfaceBlock(modifiers)
110                     // interface methods can be private
111                     && modifiers.findFirstToken(TokenTypes.LITERAL_PRIVATE) == null;
112     }
113 
114     /**
115      * Setter to control if check should apply to public members.
116      *
117      * @param applyTo new value of the property.
118      */
119     public void setApplyToPublic(boolean applyTo) {
120         applyToPublic = applyTo;
121     }
122 
123     /**
124      * Setter to control if check should apply to protected members.
125      *
126      * @param applyTo new value of the property.
127      */
128     public void setApplyToProtected(boolean applyTo) {
129         applyToProtected = applyTo;
130     }
131 
132     /**
133      * Setter to control if check should apply to package-private members.
134      *
135      * @param applyTo new value of the property.
136      */
137     public void setApplyToPackage(boolean applyTo) {
138         applyToPackage = applyTo;
139     }
140 
141     /**
142      * Setter to control if check should apply to private members.
143      *
144      * @param applyTo new value of the property.
145      */
146     public void setApplyToPrivate(boolean applyTo) {
147         applyToPrivate = applyTo;
148     }
149 
150 }