001    package edu.rice.cs.cunit.threadCheck.predicates;
002    
003    import edu.rice.cs.cunit.threadCheck.PredicateLink;
004    import edu.rice.cs.cunit.threadCheck.Combine;
005    
006    import java.lang.annotation.ElementType;
007    import java.lang.annotation.Retention;
008    import java.lang.annotation.RetentionPolicy;
009    import java.lang.annotation.Target;
010    
011    /**
012     * An annotation used to designate methods that are not allowed to be run by a thread with the
013     * specified name.
014     * @author Mathias Ricken
015     */
016    @Retention(RetentionPolicy.RUNTIME)
017    @Target({ElementType.CONSTRUCTOR,ElementType.METHOD,ElementType.TYPE})
018    
019    @PredicateLink(value = NotThreadCheckPredicates.class, method = "checkName")
020    public @interface NotThreadWithName {
021        /**
022         * Name of the thread. If the regex member is true, then this is treated as a regular expression.
023         * @return name or regular expression for the name of the thread forbidden to run
024         */
025        String value();
026    
027        /**
028         * Determines if the string in the value member is a regular expression (true) or a plain string (false).
029         * @return true if the string in the value member is a regular expression
030         */
031        boolean regex() default false;
032        
033        //
034        // nested interfaces
035        //
036        
037        /**
038         * An annotation used to designate methods that are not allowed to be run by a thread whose name is equal to the
039         * string in the field specified by class and field name.
040         */
041        @Retention(RetentionPolicy.RUNTIME)
042        @Target({ElementType.CONSTRUCTOR, ElementType.METHOD, ElementType.TYPE})
043    
044        @PredicateLink(value = NotReflectionThreadCheckPredicates.class, method = "checkName")
045        public static @interface InField {
046            /**
047             * The class that contains the field specifying the name of threads allowed to run.
048             * @return class containing the field
049             */
050            Class fieldClass();
051    
052            /**
053             * The name of the field specifying the name of threads allowed to run.
054             * @return name of the field
055             */
056            String fieldName();
057            
058            //
059            // nested interfaces
060            //
061    
062            /**
063             * An annotation used to designate methods that are not allowed to be run by a thread whose name is equal to the
064             * string in the field specified by class name and field name.
065             */
066            @Retention(RetentionPolicy.RUNTIME)
067            @Target({ElementType.CONSTRUCTOR, ElementType.METHOD, ElementType.TYPE})
068    
069            @PredicateLink(value = NotReflectionThreadCheckPredicates.class, method = "checkNameByName")
070            public static @interface ByName {
071                /**
072                 * The name of the class that contains the field specifying the name of threads allowed to run.
073                 * @return class containing the field
074                 */
075                String fieldClassName();
076    
077                /**
078                 * The name of the field specifying the name of threads allowed to run.
079                 * @return name of the field
080                 */
081                String fieldName();
082                
083                
084                //
085                // nested interfaces
086                //
087                
088                /**
089                 * Annotation used to designate methods that are not allowed to be run by a thread whose name matches
090                 * the string in any of the fields provided, i.e. the individual @NotThreadWithName.InField.ByName
091                 * annotations are combined using AND.
092                 */
093                @Retention(RetentionPolicy.RUNTIME)
094                @Target({ElementType.CONSTRUCTOR,ElementType.METHOD,ElementType.TYPE})
095                        
096                @Combine(Combine.Mode.NOT)
097                public static @interface None {
098                    NotThreadWithName.InField.ByName[] value();
099                }
100            }
101            
102            
103            /**
104             * Annotation used to designate methods that are not allowed to be run by a thread whose name matches
105             * the string in any of the fields provided, i.e. the individual @NotThreadWithName.InField annotations
106             * are combined using AND.
107             */
108            @Retention(RetentionPolicy.RUNTIME)
109            @Target({ElementType.CONSTRUCTOR,ElementType.METHOD,ElementType.TYPE})
110    
111            @Combine(Combine.Mode.AND)
112            public static @interface None {
113                NotThreadWithName.InField[] value();
114            }
115        }
116        
117        /**
118         * Annotation used to designate methods that are not allowed to be run by a thread whose name matches any
119         * of the names provided, i.e. the individual @NotThreadWithName annotations
120         * are combined using AND.
121         */
122        @Retention(RetentionPolicy.RUNTIME)
123        @Target({ElementType.CONSTRUCTOR,ElementType.METHOD,ElementType.TYPE})
124    
125        @Combine(Combine.Mode.AND)
126        public static @interface None {
127            NotThreadWithName[] value();
128        }
129    }