| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with this |
| * work for additional information regarding copyright ownership. The ASF |
| * licenses this file to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT |
| * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the |
| * License for the specific language governing permissions and limitations under |
| * the License. |
| */ |
| |
| package java.lang.annotation; |
| |
| /** |
| * Defines the interface implemented by all annotations. Note that the interface |
| * itself is <i>not</i> an annotation, and neither is an interface that simply |
| * extends this one. Only the compiler is able to create proper annotation |
| * types. |
| * |
| * @since 1.5 |
| */ |
| public interface Annotation { |
| |
| /** |
| * Returns the type of this annotation. |
| * |
| * @return A {@code Class} instance representing the annotation type. |
| */ |
| Class<? extends Annotation> annotationType(); |
| |
| /** |
| * Determines whether or not this annotation is equivalent to the annotation |
| * passed. This is determined according to the following rules: |
| * |
| * <ul> |
| * <li> |
| * Two annotations {@code x} and {@code y} are equal if and only if |
| * they are members of the same annotation type and all the member |
| * values of {@code x} are equal to the corresponding member values |
| * of {@code y}. |
| * </li> |
| * <li> |
| * The equality of primitive member values {@code x} and {@code y} |
| * is determined (in a way similar to) using the corresponding |
| * wrapper classes. For example, |
| * {@code Integer.valueOf(x).equals(Integer.valueOf(y)} is used for |
| * {@code int} values. Note: The behavior is identical to the |
| * {@code ==} operator for all but the floating point type, so the |
| * implementation may as well use {@code ==} in these cases for |
| * performance reasons. Only for the {@code float} and {@code double} |
| * types the result will be slightly different: {@code NaN} is equal |
| * to {@code NaN}, and {@code -0.0} is equal to {@code 0.0}, both of |
| * which is normally not the case. |
| * </li> |
| * <li> |
| * The equality of two array member values {@code x} and {@code y} |
| * is determined using the corresponding {@code equals(x, y)} |
| * helper function in {@link java.util.Arrays}. |
| * </li> |
| * <li> |
| * The hash code for all other member values is determined by simply |
| * calling their {@code equals()} method. |
| * </li> |
| * </ul> |
| * |
| * @param obj |
| * The object to compare to. |
| * |
| * @return {@code true} if {@code obj} is equal to this annotation, |
| * {@code false} otherwise. |
| */ |
| boolean equals(Object obj); |
| |
| /** |
| * Returns the hash code of this annotation. The hash code is determined |
| * according to the following rules: |
| * |
| * <ul> |
| * <li> |
| * The hash code of an annotation is the sum of the hash codes of |
| * its annotation members. |
| * </li> |
| * <li> |
| * The hash code of an annotation member is calculated as {@code |
| * (0x7f * n.hashCode()) ^ v.hashCode())}, where {@code n} is the |
| * name of the member (as a {@code String}) and {@code v} its value. |
| * </li> |
| * <li> |
| * The hash code for a primitive member value is determined using |
| * the corresponding wrapper type. For example, {@code |
| * Integer.valueOf(v).hashCode()} is used for an {@code int} value |
| * {@code v}. |
| * </li> |
| * <li> |
| * The hash code for an array member value {@code v} is determined |
| * using the corresponding {@code hashCode(v)} helper function in |
| * {@link java.util.Arrays}. |
| * </li> |
| * <li> |
| * The hash code for all other member values is determined by simply |
| * calling their {@code hashCode} method. |
| * </li> |
| * </ul> |
| * |
| * @return the hash code. |
| */ |
| int hashCode(); |
| |
| /** |
| * Returns a {@code String} representation of this annotation. It is not |
| * strictly defined what the representation has to look like, but it usually |
| * consists of the name of the annotation, preceded by a "@". If the |
| * annotation contains field members, their names and values are also |
| * included in the result. |
| * |
| * @return the {@code String} that represents this annotation. |
| */ |
| String toString(); |
| } |