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.Retention;
007    import java.lang.annotation.RetentionPolicy;
008    import java.lang.annotation.Target;
009    import java.lang.annotation.ElementType;
010    
011    /**
012     * An annotation used to designate methods that are only allowed to be run when the monitor of
013     * the field specified by class and field name is owned by some thread, regardless which it is.
014     *
015     * @author Mathias Ricken
016     */
017    @Retention(RetentionPolicy.RUNTIME)
018    @Target({ElementType.CONSTRUCTOR, ElementType.METHOD, ElementType.TYPE})
019    
020    @PredicateLink(value = ReflectionThreadCheckPredicates.class, method = "checkSynchronizedFieldByAnyThread")
021    public @interface AnySynchronizedField {
022        /**
023         * The class that contains the field whose monitor some thread has to own.
024         *
025         * @return class containing the field
026         */
027        Class fieldClass();
028    
029        /**
030         * The name of the field whose monitor sine thread has to own.
031         *
032         * @return name of the field
033         */
034        String fieldName();
035    
036        //
037        // nested interfaces
038        //
039    
040        /**
041         * An annotation used to designate methods that are only allowed to be run when the monitor of
042         * the field specified by class name and field name is owned by some thread, regardless which it is.
043         *
044         * @author Mathias Ricken
045         */
046        @Retention(RetentionPolicy.RUNTIME)
047        @Target({ElementType.CONSTRUCTOR, ElementType.METHOD, ElementType.TYPE})
048    
049        @PredicateLink(value = ReflectionThreadCheckPredicates.class, method = "checkSynchronizedFieldByAnyThreadByName")
050        public static @interface ByName {
051            /**
052             * The name of the class that contains the field whose monitor some thread has to own.
053             *
054             * @return class containing the field
055             */
056            String fieldClassName();
057    
058            /**
059             * The name of the field whose monitor the thread some to own.
060             *
061             * @return name of the field
062             */
063            String fieldName();
064    
065            //
066            // nested interfaces
067            //
068    
069            /**
070             * An annotation used to designate methods that are only allowed to be run when one or more of the
071             * monitors of the fields specified are owned by some thread, regardless which it is, i.e. the individual
072             * @AnySynchronizedField.ByName annotations are combined using OR.
073             */
074            @Retention(RetentionPolicy.RUNTIME)
075            @Target({ElementType.CONSTRUCTOR,ElementType.METHOD,ElementType.TYPE})
076    
077            @Combine(Combine.Mode.OR)
078            public static @interface Any {
079                AnySynchronizedField.ByName[] value();
080            }
081    
082            /**
083             * An annotation used to designate methods that are only allowed to be run when all of the
084             * monitors of the fields specified are owned by some thread, regardless which it is, i.e. the individual
085             * @AnySynchronizedField.ByName annotations are combined using AND.
086             */
087            @Retention(RetentionPolicy.RUNTIME)
088            @Target({ElementType.CONSTRUCTOR,ElementType.METHOD,ElementType.TYPE})
089    
090            @Combine(Combine.Mode.AND)
091            public static @interface All {
092                AnySynchronizedField.ByName[] value();
093            }
094        }
095    
096        /**
097         * An annotation used to designate methods that are only allowed to be run when one or more of the
098         * monitors of the fields specified are owned by some thread, regardless which it is, i.e. the individual
099         * @AnySynchronizedField annotations are combined using OR.
100         */
101        @Retention(RetentionPolicy.RUNTIME)
102        @Target({ElementType.CONSTRUCTOR,ElementType.METHOD,ElementType.TYPE})
103    
104        @Combine(Combine.Mode.OR)
105        public static @interface Any {
106            AnySynchronizedField[] value();
107        }
108    
109        /**
110         * An annotation used to designate methods that are only allowed to be run when all of the
111         * monitors of the fields specified are owned by some thread, regardless which it is, i.e. the individual
112         * @AnySynchronizedField annotations are combined using AND.
113         */
114        @Retention(RetentionPolicy.RUNTIME)
115        @Target({ElementType.CONSTRUCTOR,ElementType.METHOD,ElementType.TYPE})
116    
117        @Combine(Combine.Mode.AND)
118        public static @interface All {
119            AnySynchronizedField[] value();
120        }
121    }